using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.PostProcessing;
using UnityEngine.UI;
using ValheimPerformanceOverhaul.AI;
using ValheimPerformanceOverhaul.Audio;
using ValheimPerformanceOverhaul.Core;
using ValheimPerformanceOverhaul.Graphics;
using ValheimPerformanceOverhaul.Network;
using ValheimPerformanceOverhaul.ObjectPooling;
using ValheimPerformanceOverhaul.Optimizations;
using ValheimPerformanceOverhaul.Pieces;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ValheimPerformanceOverhaul")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ValheimPerformanceOverhaul")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e1d59e72-fa59-450d-94cd-86cc02deca70")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ValheimPerformanceOverhaul
{
	[HarmonyPatch(typeof(Resources), "UnloadUnusedAssets")]
	public static class GCPatches
	{
		private delegate bool InAttackDelegate(Player player);

		private static FieldRef<Character, Vector3> _getMoveDirFast;

		private static InAttackDelegate _inAttackFast;

		private static bool _delegatesInitialized;

		private const float MAX_LOW_LATENCY_SECONDS = 45f;

		private static float _lowLatencyStartTime;

		private static bool _isInLowLatency;

		static GCPatches()
		{
			_lowLatencyStartTime = -1f;
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(Character), "m_moveDir");
				MethodInfo methodInfo = AccessTools.Method(typeof(Player), "InAttack", (Type[])null, (Type[])null);
				if (fieldInfo != null && methodInfo != null)
				{
					_getMoveDirFast = AccessTools.FieldRefAccess<Character, Vector3>(fieldInfo);
					_inAttackFast = (InAttackDelegate)Delegate.CreateDelegate(typeof(InAttackDelegate), methodInfo);
					_delegatesInitialized = true;
					Plugin.Log.LogInfo((object)"[GC] Fast delegates initialized.");
				}
				else
				{
					Plugin.Log.LogWarning((object)"[GC] Private fields not found — GC optimization disabled.");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[GC] Failed to initialize delegates: " + ex.Message));
				_delegatesInitialized = false;
			}
		}

		[HarmonyPriority(600)]
		[HarmonyPrefix]
		private static bool PreventUnloadWhenBusy()
		{
			if (!Plugin.GcControlEnabled.Value || !_delegatesInitialized)
			{
				return true;
			}
			return !IsPlayerBusy();
		}

		public static void TickGCMode()
		{
			if (!Plugin.GcControlEnabled.Value || !_delegatesInitialized)
			{
				return;
			}
			bool flag = IsPlayerBusy();
			if (flag && !_isInLowLatency)
			{
				GCSettings.LatencyMode = GCLatencyMode.LowLatency;
				_isInLowLatency = true;
				_lowLatencyStartTime = Time.unscaledTime;
			}
			else if (!flag && _isInLowLatency)
			{
				ExitLowLatency();
			}
			else if (_isInLowLatency && Time.unscaledTime - _lowLatencyStartTime > 45f)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)"[GC] Safety timeout — forcing collect and resetting mode.");
				}
				ExitLowLatency();
				GC.Collect(0, GCCollectionMode.Optimized);
				if (IsPlayerBusy())
				{
					GCSettings.LatencyMode = GCLatencyMode.LowLatency;
					_isInLowLatency = true;
					_lowLatencyStartTime = Time.unscaledTime;
				}
			}
		}

		private static void ExitLowLatency()
		{
			GCSettings.LatencyMode = GCLatencyMode.Interactive;
			_isInLowLatency = false;
			_lowLatencyStartTime = -1f;
		}

		public static bool IsPlayerBusyProxy()
		{
			if (_delegatesInitialized)
			{
				return IsPlayerBusy();
			}
			return false;
		}

		private static bool IsPlayerBusy()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsDead())
			{
				return false;
			}
			try
			{
				if (!((Character)localPlayer).IsOnGround() || ((Character)localPlayer).IsSwimming() || ((Character)localPlayer).IsTeleporting())
				{
					return true;
				}
				if (((Vector3)(ref _getMoveDirFast.Invoke((Character)(object)localPlayer))).sqrMagnitude > 0.01f)
				{
					return true;
				}
				if (_inAttackFast(localPlayer))
				{
					return true;
				}
			}
			catch (Exception ex)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogWarning((object)("[GC] Error checking player state: " + ex.Message));
				}
				return false;
			}
			return false;
		}
	}
	public static class JitPatches
	{
		private static bool _warmedUp;

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		[HarmonyPostfix]
		private static void WarmupGameMethods(Player __instance)
		{
			if (_warmedUp || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || !Plugin.JitWarmupEnabled.Value)
			{
				return;
			}
			_warmedUp = true;
			try
			{
				PrepareMethod(typeof(Character), "Damage", "Character.Damage");
				PrepareMethod(typeof(Player), "StartAttack", "Player.StartAttack");
				PrepareMethod(typeof(Attack), "DoMeleeAttack", "Attack.DoMeleeAttack");
				PrepareMethod(typeof(Player), "GetHoverObject", "Player.GetHoverObject");
				PrepareMethod(typeof(Player), "GetHoverCreature", "Player.GetHoverCreature");
				PrepareMethod(typeof(Player), "GetHoveringPiece", "Player.GetHoveringPiece");
				PrepareMethod(typeof(Player), "UpdatePlacement", "Player.UpdatePlacement");
				PrepareMethod(typeof(InventoryGui), "Show", "InventoryGui.Show");
				PrepareMethod(typeof(Minimap), "SetMapMode", "Minimap.SetMapMode");
				PrepareMethod(typeof(EnvMan), "GetCurrentBiome", "EnvMan.GetCurrentBiome");
				Plugin.Log.LogInfo((object)"[JIT] Warm-up complete.");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[JIT] Warm-up error: " + ex.Message));
			}
		}

		private static void PrepareMethod(Type type, string methodName, string logLabel)
		{
			if (type == null || string.IsNullOrEmpty(methodName))
			{
				return;
			}
			try
			{
				MethodInfo methodInfo = AccessTools.Method(type, methodName, (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					if (Plugin.DebugLoggingEnabled.Value)
					{
						Plugin.Log.LogWarning((object)("[JIT] Method not found: " + logLabel));
					}
					return;
				}
				RuntimeHelpers.PrepareMethod(methodInfo.MethodHandle);
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)("[JIT] Warmed: " + logLabel));
				}
			}
			catch (Exception ex)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogWarning((object)("[JIT] Could not prepare " + logLabel + ": " + ex.Message));
				}
			}
		}
	}
	[BepInPlugin("com.Skarif.ValheimPerformanceOverhaul", "Valheim Performance Overhaul", "2.7.0")]
	public class Plugin : BaseUnityPlugin
	{
		private const string PluginGUID = "com.Skarif.ValheimPerformanceOverhaul";

		private const string PluginName = "Valheim Performance Overhaul";

		public const string PluginVersion = "2.7.0";

		private readonly Harmony _harmony = new Harmony("com.Skarif.ValheimPerformanceOverhaul");

		public static ManualLogSource Log;

		public static Plugin Instance;

		public static ConfigEntry<bool> DebugLoggingEnabled;

		public static ConfigEntry<bool> GcControlEnabled;

		public static ConfigEntry<bool> DistanceCullerEnabled;

		public static ConfigEntry<float> CreatureCullDistance;

		public static ConfigEntry<float> PieceCullDistance;

		public static ConfigEntry<bool> AiThrottlingEnabled;

		public static ConfigEntry<string> CullerExclusions;

		public static ConfigEntry<bool> ObjectPoolingEnabled;

		public static ConfigEntry<bool> JitWarmupEnabled;

		public static ConfigEntry<bool> LightCullingEnabled;

		public static ConfigEntry<int> MaxActiveLights;

		public static ConfigEntry<float> LightCullDistance;

		public static ConfigEntry<int> MaxShadowCasters;

		public static ConfigEntry<float> ShadowCullDistance;

		public static ConfigEntry<bool> LightLODEnabled;

		public static ConfigEntry<float> LightLODFullDistance;

		public static ConfigEntry<float> LightLODNoShadowDistance;

		public static ConfigEntry<float> LightLODEmissiveDistance;

		public static ConfigEntry<float> LightLODBillboardDistance;

		public static ConfigEntry<bool> AudioPoolingEnabled;

		public static ConfigEntry<int> AudioPoolSize;

		public static ConfigEntry<bool> GraphicsSettingsEnabled;

		public static ConfigEntry<float> ConfigShadowDistance;

		public static ConfigEntry<int> ConfigShadowResolution;

		public static ConfigEntry<int> ConfigShadowCascades;

		public static ConfigEntry<float> ConfigTerrainQuality;

		public static ConfigEntry<bool> ConfigReflections;

		public static ConfigEntry<bool> ConfigBloom;

		public static ConfigEntry<float> PathCacheDistance;

		public static ConfigEntry<bool> PieceOptimizationEnabled;

		public static ConfigEntry<float> PieceSupportCacheDuration;

		public static ConfigEntry<bool> ParticleOptimizationEnabled;

		public static ConfigEntry<float> ParticleCullDistance;

		public static ConfigEntry<int> MaxActiveParticles;

		public static ConfigEntry<float> TorchParticleLifetime;

		public static ConfigEntry<bool> VegetationOptimizationEnabled;

		public static ConfigEntry<float> GrassRenderDistance;

		public static ConfigEntry<float> GrassDensityMultiplier;

		public static ConfigEntry<float> DetailObjectDistance;

		public static ConfigEntry<float> DetailDensity;

		public static ConfigEntry<int> TerrainMaxLOD;

		public static ConfigEntry<bool> AnimatorOptimizationEnabled;

		public static ConfigEntry<bool> MinimapOptimizationEnabled;

		public static ConfigEntry<bool> TamedIdleOptimizationEnabled;

		public static ConfigEntry<float> TamedIdleDistanceFromCombat;

		public static ConfigEntry<float> TamedIdleBaseDetectionRadius;

		public static ConfigEntry<bool> LightFlickerOptimizationEnabled;

		public static ConfigEntry<bool> SmokeOptimizationEnabled;

		public static ConfigEntry<float> SmokeLiftForce;

		public static ConfigEntry<bool> EngineQualitySettingsEnabled;

		public static ConfigEntry<int> ParticleRaycastBudget;

		public static ConfigEntry<bool> SkipIntroEnabled;

		public static ConfigEntry<bool> FrameBudgetGuardEnabled;

		public static ConfigEntry<float> FrameBudgetThresholdMs;

		public static ConfigEntry<float> FrameBudgetThrottledDelta;

		public static ConfigEntry<float> FrameBudgetNormalDelta;

		public static ConfigEntry<int> ConfigSkinWeights;

		public static ConfigEntry<bool> PieceSupportSmartInvalidation;

		public static ConfigEntry<bool> SmartZoneOwnershipEnabled;

		public static ConfigEntry<int> ZonePingThreshold;

		public static ConfigEntry<int> ZonePingHysteresis;

		public static ConfigEntry<float> ZoneUpdateInterval;

		public static ConfigEntry<bool> GPUInstancingEnabled;

		public static ConfigEntry<bool> GPUInstancingDeduplicateMaterials;

		public static ConfigEntry<bool> LODGenerationEnabled;

		public static ConfigEntry<float> LOD1Quality;

		public static ConfigEntry<float> LOD2Quality;

		public static ConfigEntry<int> LODMinVertexCount;

		public static ConfigEntry<bool> StaticBatchingEnabled;

		public static ConfigEntry<float> StaticBatchingSettleCooldown;

		public static ConfigEntry<bool> TextureOptimizationEnabled;

		public static ConfigEntry<float> TextureDownscaleMultiplier;

		public static ConfigEntry<int> TextureMinSize;

		private float _poolMaintenanceTimer;

		private const float POOL_MAINTENANCE_INTERVAL = 30f;

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			HardwareProfiler.Initialize();
			SetupConfig();
			Log.LogInfo((object)"Initializing Valheim Performance Overhaul v2.7.0...");
			if (GraphicsSettingsEnabled.Value)
			{
				ApplyImmediateGraphicsSettings();
			}
			Log.LogInfo((object)"Applying Harmony patches...");
			try
			{
				_harmony.PatchAll(Assembly.GetExecutingAssembly());
				Log.LogInfo((object)"All patches applied successfully.");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Error applying patches: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void Start()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			if (StaticBatchingEnabled.Value && (Object)(object)StaticBatchingManager.Instance == (Object)null)
			{
				new GameObject("_VPO_StaticBatchingManager").AddComponent<StaticBatchingManager>();
				Log.LogInfo((object)"[StaticBatching] System initialized at startup.");
			}
			if (LODGenerationEnabled.Value)
			{
				LODGenerator.SetupManager();
				Log.LogInfo((object)"[LODGenerator] Persistent manager initialized at startup.");
			}
			if (GPUInstancingEnabled.Value)
			{
				OptimizationTierResolver.Initialize();
			}
			if (AiThrottlingEnabled.Value)
			{
				AIOptimizerManager.Initialize();
				Log.LogInfo((object)"[AI] Optimizer manager initialized.");
			}
			if (ObjectPoolingEnabled.Value)
			{
				ObjectPoolManager.Initialize();
				Log.LogInfo((object)"[ObjectPooling] System initialized.");
			}
			if (AudioPoolingEnabled.Value)
			{
				AudioPoolManager.Initialize();
				Log.LogInfo((object)"[AudioPooling] System initialized.");
			}
			if (DistanceCullerEnabled.Value)
			{
				GameObject val = new GameObject("_VPO_DistanceCullerManager");
				val.AddComponent<DistanceCullerManager>();
				Object.DontDestroyOnLoad((Object)val);
				Log.LogInfo((object)"[DistanceCuller] Manager initialized.");
			}
			if (FrameBudgetGuardEnabled.Value)
			{
				GameObject val2 = new GameObject("_VPO_FrameBudgetGuard");
				val2.AddComponent<FrameBudgetGuard>();
				Object.DontDestroyOnLoad((Object)val2);
				Log.LogInfo((object)"[FrameBudgetGuard] Initialized.");
			}
		}

		private void SetupConfig()
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Expected O, but got Unknown
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Expected O, but got Unknown
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Expected O, but got Unknown
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Expected O, but got Unknown
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Expected O, but got Unknown
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Expected O, but got Unknown
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Expected O, but got Unknown
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Expected O, but got Unknown
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0495: Expected O, but got Unknown
			//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Expected O, but got Unknown
			//IL_0548: Unknown result type (might be due to invalid IL or missing references)
			//IL_0552: Expected O, but got Unknown
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_058f: Expected O, but got Unknown
			//IL_05e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ec: Expected O, but got Unknown
			//IL_067f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0689: Expected O, but got Unknown
			//IL_06b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bd: Expected O, but got Unknown
			//IL_06f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fa: Expected O, but got Unknown
			//IL_074d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0757: Expected O, but got Unknown
			//IL_078a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0794: Expected O, but got Unknown
			//IL_07c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d1: Expected O, but got Unknown
			//IL_0804: Unknown result type (might be due to invalid IL or missing references)
			//IL_080e: Expected O, but got Unknown
			//IL_0835: Unknown result type (might be due to invalid IL or missing references)
			//IL_083f: Expected O, but got Unknown
			//IL_08cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d6: Expected O, but got Unknown
			//IL_0900: Unknown result type (might be due to invalid IL or missing references)
			//IL_090a: Expected O, but got Unknown
			//IL_093d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0947: Expected O, but got Unknown
			//IL_09a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_09af: Expected O, but got Unknown
			//IL_09e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ec: Expected O, but got Unknown
			//IL_0a5f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a69: Expected O, but got Unknown
			//IL_0ab9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac3: Expected O, but got Unknown
			//IL_0b36: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b40: Expected O, but got Unknown
			//IL_0b73: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b7d: Expected O, but got Unknown
			//IL_0bb0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bba: Expected O, but got Unknown
			//IL_0c4d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c57: Expected O, but got Unknown
			//IL_0c8a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c94: Expected O, but got Unknown
			//IL_0cc7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cd1: Expected O, but got Unknown
			//IL_0d24: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d2e: Expected O, but got Unknown
			//IL_0d81: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d8b: Expected O, but got Unknown
			//IL_0dbe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dc8: Expected O, but got Unknown
			DebugLoggingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("1. General", "Enable Debug Logging", false, "Enables detailed diagnostic logs.");
			GcControlEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("2. GC Control", "Enabled", true, "Prevents garbage collection during combat or movement.");
			DistanceCullerEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("3. Distance Culler", "Enabled", true, "Disables logic for distant objects.");
			CreatureCullDistance = ((BaseUnityPlugin)this).Config.Bind<float>("3. Distance Culler", "Creature Cull Distance", 80f, new ConfigDescription("Distance at which creatures sleep.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(40f, 200f), Array.Empty<object>()));
			PieceCullDistance = ((BaseUnityPlugin)this).Config.Bind<float>("3. Distance Culler", "Piece Cull Distance", 100f, new ConfigDescription("Distance at which build pieces sleep.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(50f, 300f), Array.Empty<object>()));
			AiThrottlingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("3. Distance Culler", "Enable AI Throttling", true, "Reduces how often distant AI updates.");
			CullerExclusions = ((BaseUnityPlugin)this).Config.Bind<string>("3. Distance Culler", "Exclusions", "TombStone,portal_wood", "Comma-separated list of prefab names to never cull. Objects with ZSyncTransform+Rigidbody (doors, torches) are automatically excluded in code and do not need to be listed here.");
			ObjectPoolingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("4. Object Pooling", "Enabled", true, "Reuses ItemDrop objects.");
			JitWarmupEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("5. JIT Warm-up", "Enabled", true, "Pre-compiles critical methods at game start.");
			LightCullingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("6. Light Culling", "Enabled", true, "Disables distant light sources.");
			MaxActiveLights = ((BaseUnityPlugin)this).Config.Bind<int>("6. Light Culling", "Max Active Lights", 15, new ConfigDescription("Max active lights.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(5, 50), Array.Empty<object>()));
			LightCullDistance = ((BaseUnityPlugin)this).Config.Bind<float>("6. Light Culling", "Light Cull Distance", 60f, new ConfigDescription("Max distance for active lights.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(20f, 150f), Array.Empty<object>()));
			MaxShadowCasters = ((BaseUnityPlugin)this).Config.Bind<int>("6. Light Culling", "Max Shadow Casters", 5, new ConfigDescription("Max shadow casters.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 15), Array.Empty<object>()));
			ShadowCullDistance = ((BaseUnityPlugin)this).Config.Bind<float>("6. Light Culling", "Shadow Cull Distance", 30f, new ConfigDescription("Distance for shadows.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 80f), Array.Empty<object>()));
			LightLODEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("6. Light Culling", "Enable Light LOD System", true, "Enables Level of Detail system for lights.");
			LightLODFullDistance = ((BaseUnityPlugin)this).Config.Bind<float>("6. Light Culling", "LOD Full Light Distance", 20f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 50f), Array.Empty<object>()));
			LightLODNoShadowDistance = ((BaseUnityPlugin)this).Config.Bind<float>("6. Light Culling", "LOD No Shadow Distance", 40f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(20f, 80f), Array.Empty<object>()));
			LightLODEmissiveDistance = ((BaseUnityPlugin)this).Config.Bind<float>("6. Light Culling", "LOD Emissive Distance", 70f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(40f, 120f), Array.Empty<object>()));
			LightLODBillboardDistance = ((BaseUnityPlugin)this).Config.Bind<float>("6. Light Culling", "LOD Billboard Distance", 100f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(60f, 200f), Array.Empty<object>()));
			AudioPoolingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("7. Audio Optimization", "Enabled", true, "Reuses sound effect objects.");
			AudioPoolSize = ((BaseUnityPlugin)this).Config.Bind<int>("7. Audio Optimization", "Total Pool Size", 32, new ConfigDescription("Total pooled sources.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(16, 128), Array.Empty<object>()));
			GraphicsSettingsEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("8. Graphics Settings", "Enabled", true, "Enables advanced graphics settings.");
			ConfigShadowDistance = ((BaseUnityPlugin)this).Config.Bind<float>("8. Graphics Settings", "Shadow Distance", 50f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(20f, 150f), Array.Empty<object>()));
			ConfigShadowResolution = ((BaseUnityPlugin)this).Config.Bind<int>("8. Graphics Settings", "Shadow Resolution", 512, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueList<int>(new int[4] { 512, 1024, 2048, 4096 }), Array.Empty<object>()));
			ConfigShadowCascades = ((BaseUnityPlugin)this).Config.Bind<int>("8. Graphics Settings", "Shadow Cascades", 1, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 4), Array.Empty<object>()));
			ConfigTerrainQuality = ((BaseUnityPlugin)this).Config.Bind<float>("8. Graphics Settings", "Terrain Quality Multiplier", 0.7f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 2f), Array.Empty<object>()));
			ConfigReflections = ((BaseUnityPlugin)this).Config.Bind<bool>("8. Graphics Settings", "Enable Reflections", false, "Enables screen-space reflections.");
			ConfigBloom = ((BaseUnityPlugin)this).Config.Bind<bool>("8. Graphics Settings", "Enable Bloom", false, "Enables bloom glow effect.");
			ConfigSkinWeights = ((BaseUnityPlugin)this).Config.Bind<int>("8. Graphics Settings", "Skin Weights (Bones)", 2, new ConfigDescription("Number of bones per vertex for animations. 4 = Vanilla, 2 = Optimal (Recommended), 1 = Max FPS.", (AcceptableValueBase)(object)new AcceptableValueList<int>(new int[3] { 1, 2, 4 }), Array.Empty<object>()));
			PathCacheDistance = ((BaseUnityPlugin)this).Config.Bind<float>("9. AI Optimization", "Path Cache Distance", 2f, new ConfigDescription("AI path caching distance.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 8f), Array.Empty<object>()));
			PieceOptimizationEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("10. Piece Optimization", "Enabled", true, "Optimizes building pieces.");
			PieceSupportCacheDuration = ((BaseUnityPlugin)this).Config.Bind<float>("10. Piece Optimization", "Support Cache Duration (seconds)", 5f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 30f), Array.Empty<object>()));
			PieceSupportSmartInvalidation = ((BaseUnityPlugin)this).Config.Bind<bool>("10. Piece Optimization", "Smart Cache Invalidation", false, "Instantly recalculates the stability of adjacent buildings when a chunk is destroyed.");
			RainDamagePatch.DisableRainDamage = ((BaseUnityPlugin)this).Config.Bind<bool>("10. Piece Optimization", "Disable Rain Damage", false, "Completely disables wear and tear of wooden buildings from rain and rotting in water.");
			ParticleOptimizationEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("11. Particle Optimization", "Enabled", true, "Optimizes particle systems.");
			ParticleCullDistance = ((BaseUnityPlugin)this).Config.Bind<float>("11. Particle Optimization", "Particle Cull Distance", 50f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(20f, 100f), Array.Empty<object>()));
			MaxActiveParticles = ((BaseUnityPlugin)this).Config.Bind<int>("11. Particle Optimization", "Max Active Particle Systems", 30, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 100), Array.Empty<object>()));
			TorchParticleLifetime = ((BaseUnityPlugin)this).Config.Bind<float>("11. Particle Optimization", "Torch Particle Lifetime", 0.8f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.2f, 2f), Array.Empty<object>()));
			VegetationOptimizationEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("12. Vegetation Optimization", "Enabled", true, "Optimizes grass and details.");
			GrassRenderDistance = ((BaseUnityPlugin)this).Config.Bind<float>("12. Vegetation Optimization", "Grass Render Distance", 60f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(30f, 120f), Array.Empty<object>()));
			GrassDensityMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("12. Vegetation Optimization", "Grass Density Multiplier", 0.7f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 1f), Array.Empty<object>()));
			DetailObjectDistance = ((BaseUnityPlugin)this).Config.Bind<float>("12. Vegetation Optimization", "Detail Object Distance", 80f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(40f, 150f), Array.Empty<object>()));
			DetailDensity = ((BaseUnityPlugin)this).Config.Bind<float>("12. Vegetation Optimization", "Detail Density", 0.7f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 1f), Array.Empty<object>()));
			TerrainMaxLOD = ((BaseUnityPlugin)this).Config.Bind<int>("12. Vegetation Optimization", "Terrain Max LOD", 1, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 2), Array.Empty<object>()));
			AnimatorOptimizationEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("13. Animator Optimization", "Enabled", true, "Optimizes character animations.");
			MinimapOptimizationEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("14. Minimap Optimization", "Enabled", true, "Reduces minimap texture updates.");
			SmartZoneOwnershipEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("14. Network Optimization", "Smart Zone Ownership", false, "[Только Сервер] Автоматически передает управление ИИ мобов игроку с наименьшим пингом в зоне.");
			ZonePingThreshold = ((BaseUnityPlugin)this).Config.Bind<int>("14. Network Optimization", "Zone Ping Threshold (ms)", 120, new ConfigDescription("Ping, at which the server will start looking for a new owner for the zone.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(50, 500), Array.Empty<object>()));
			ZonePingHysteresis = ((BaseUnityPlugin)this).Config.Bind<int>("14. Network Optimization", "Zone Ping Hysteresis (ms)", 30, new ConfigDescription("The difference in ping required to transfer possession.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 100), Array.Empty<object>()));
			ZoneUpdateInterval = ((BaseUnityPlugin)this).Config.Bind<float>("14. Network Optimization", "Zone Update Interval (sec)", 5f, new ConfigDescription("How often does the server check pings in zones?", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 20f), Array.Empty<object>()));
			NetworkManager.SetupConfigs(((BaseUnityPlugin)this).Config);
			TamedIdleOptimizationEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("16. Tamed Mob Idle Optimization", "Enabled", true, "Idle mode for tamed mobs.");
			TamedIdleDistanceFromCombat = ((BaseUnityPlugin)this).Config.Bind<float>("16. Tamed Mob Idle Optimization", "Idle Distance From Combat", 5f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(3f, 30f), Array.Empty<object>()));
			TamedIdleBaseDetectionRadius = ((BaseUnityPlugin)this).Config.Bind<float>("16. Tamed Mob Idle Optimization", "Base Detection Radius", 30f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(15f, 60f), Array.Empty<object>()));
			LightFlickerOptimizationEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("17. Light Flicker Optimization", "Enabled", true, "Fixes light intensity to base value.");
			SmokeOptimizationEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("18. Smoke Physics Optimization", "Enabled", true, "Simplified smoke aerodynamics.");
			SmokeLiftForce = ((BaseUnityPlugin)this).Config.Bind<float>("18. Smoke Physics Optimization", "Smoke Lift Force", 3.5f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10f), Array.Empty<object>()));
			EngineQualitySettingsEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("19. Engine Quality Settings", "Enabled", true, "Low-level Unity tweaks.");
			ParticleRaycastBudget = ((BaseUnityPlugin)this).Config.Bind<int>("19. Engine Quality Settings", "Particle Raycast Budget", 1024, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<int>(64, 4096), Array.Empty<object>()));
			SkipIntroEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("20. Skip Intro", "Enabled", true, "Skips logos.");
			FrameBudgetGuardEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("21. Frame Budget Guard", "Enabled", true, "Limits maximumDeltaTime on frame spikes.");
			FrameBudgetThresholdMs = ((BaseUnityPlugin)this).Config.Bind<float>("21. Frame Budget Guard", "Freeze Threshold (ms)", 28f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(16f, 100f), Array.Empty<object>()));
			FrameBudgetThrottledDelta = ((BaseUnityPlugin)this).Config.Bind<float>("21. Frame Budget Guard", "Throttled MaxDeltaTime", 0.045f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.02f, 0.1f), Array.Empty<object>()));
			FrameBudgetNormalDelta = ((BaseUnityPlugin)this).Config.Bind<float>("21. Frame Budget Guard", "Normal MaxDeltaTime", 0.07f, new ConfigDescription("", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.03f, 0.2f), Array.Empty<object>()));
			GPUInstancingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("22. GPU Instancing", "Enabled", true, "Enables GPU Instancing on highly repetitive world objects (flora, rocks, pieces).");
			GPUInstancingDeduplicateMaterials = ((BaseUnityPlugin)this).Config.Bind<bool>("22. GPU Instancing", "Deduplicate Materials", true, "Merges duplicate material instances to maximize instancing batch sizes.");
			LODGenerationEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("23. LOD Generation", "Enabled", true, "Enables asynchronous runtime generation of Level of Detail (LOD) groups for static world objects.");
			LOD1Quality = ((BaseUnityPlugin)this).Config.Bind<float>("23. LOD Generation", "LOD1 Mesh Quality", 0.5f, new ConfigDescription("Vertex reduction target for LOD1 (50% target).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 0.9f), Array.Empty<object>()));
			LOD2Quality = ((BaseUnityPlugin)this).Config.Bind<float>("23. LOD Generation", "LOD2 Mesh Quality", 0.15f, new ConfigDescription("Vertex reduction target for LOD2 (15% target).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 0.5f), Array.Empty<object>()));
			LODMinVertexCount = ((BaseUnityPlugin)this).Config.Bind<int>("23. LOD Generation", "Min Vertex Count", 300, new ConfigDescription("Minimum vertex count of a mesh to qualify for LOD generation. Higher values target only high-poly meshes, reducing CPU overhead.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(150, 5000), Array.Empty<object>()));
			StaticBatchingEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("24. Static Batching", "Enabled", true, "Combines unique static geometry (dungeons, ruins, pillars, cliffs) per sector in runtime using Unity's StaticBatchingUtility.");
			StaticBatchingSettleCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("24. Static Batching", "Settle Cooldown (seconds)", 2f, new ConfigDescription("Time to wait after the last object spawns in a sector before combining them into a static batch.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 10f), Array.Empty<object>()));
			TextureOptimizationEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("27. Texture Optimization", "Enabled", false, "Enables runtime background downscaling and GPU compression of secondary object textures to save VRAM.");
			TextureDownscaleMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("27. Texture Optimization", "Downscale Multiplier", 0.5f, new ConfigDescription("Texture scale factor (0.5 means halving width and height, reducing memory footprint by 75%).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1f), Array.Empty<object>()));
			TextureMinSize = ((BaseUnityPlugin)this).Config.Bind<int>("27. Texture Optimization", "Min Texture Size to Process", 512, new ConfigDescription("Minimum texture size (width or height) to qualify for optimization. Smaller textures/icons are ignored.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(128, 2048), Array.Empty<object>()));
		}

		private void ApplyImmediateGraphicsSettings()
		{
			try
			{
				QualitySettings.shadowDistance = ConfigShadowDistance.Value;
				switch (ConfigShadowResolution.Value)
				{
				case 512:
					QualitySettings.shadowResolution = (ShadowResolution)0;
					break;
				case 1024:
					QualitySettings.shadowResolution = (ShadowResolution)1;
					break;
				case 2048:
					QualitySettings.shadowResolution = (ShadowResolution)2;
					break;
				case 4096:
					QualitySettings.shadowResolution = (ShadowResolution)3;
					break;
				default:
					QualitySettings.shadowResolution = (ShadowResolution)0;
					break;
				}
				QualitySettings.shadowCascades = ConfigShadowCascades.Value;
				Log.LogInfo((object)"[Graphics] Applied immediate graphics settings.");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[Graphics] Failed to apply settings: " + ex.Message));
			}
		}

		private void OnDestroy()
		{
			Log.LogInfo((object)"Unpatching all Valheim Performance Overhaul methods.");
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
			if (GcControlEnabled != null && GcControlEnabled.Value)
			{
				GCPatches.TickGCMode();
			}
			if (ObjectPoolingEnabled == null || !ObjectPoolingEnabled.Value)
			{
				return;
			}
			_poolMaintenanceTimer += Time.deltaTime;
			if (_poolMaintenanceTimer >= 30f)
			{
				_poolMaintenanceTimer = 0f;
				ObjectPoolManager.PerformMaintenance();
				if (DebugLoggingEnabled.Value)
				{
					ObjectPoolManager.LogPoolStats();
				}
			}
		}
	}
	public class DistanceCuller : MonoBehaviour
	{
		private readonly List<MonoBehaviour> _culledComponents = new List<MonoBehaviour>();

		private ZNetView _zNetView;

		private bool _isCulled;

		private bool _isCharacter;

		private Transform _transform;

		public float CullDistance = 80f;

		private float _cullDistanceSqr;

		private float _wakeUpDistanceSqr;

		private const float HYSTERESIS = 15f;

		private void Awake()
		{
			_transform = ((Component)this).transform;
			_zNetView = ((Component)this).GetComponent<ZNetView>();
			if ((Object)(object)_zNetView == (Object)null || !_zNetView.IsValid())
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			_isCharacter = (Object)(object)((Component)this).GetComponent<Character>() != (Object)null;
			try
			{
				_cullDistanceSqr = (CullDistance + 15f) * (CullDistance + 15f);
				_wakeUpDistanceSqr = (CullDistance - 15f) * (CullDistance - 15f);
				if (!_isCharacter)
				{
					CollectComponents();
				}
				((MonoBehaviour)this).StartCoroutine(RegisterNextFrame());
			}
			catch (Exception ex)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogError((object)("[DistanceCuller] Error in Awake: " + ex.Message));
				}
				Object.Destroy((Object)(object)this);
			}
		}

		private IEnumerator RegisterNextFrame()
		{
			yield return null;
			if (!((Object)(object)this == (Object)null) && !((Object)(object)_zNetView == (Object)null) && _zNetView.IsValid())
			{
				DistanceCullerManager.Instance?.RegisterCuller(this);
			}
		}

		private void CollectComponents()
		{
			MonoBehaviour[] componentsInChildren = ((Component)this).GetComponentsInChildren<MonoBehaviour>(true);
			if (componentsInChildren == null)
			{
				return;
			}
			MonoBehaviour[] array = componentsInChildren;
			foreach (MonoBehaviour val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)this) && !(val is ZNetView) && !(val is ZSyncTransform) && !(val is DistanceCuller) && !(val is Character) && !(val is Humanoid) && (!Plugin.AiThrottlingEnabled.Value || !(val is BaseAI)) && !(val is Fireplace) && !(val is Hoverable) && !(val is Interactable))
				{
					_culledComponents.Add(val);
				}
			}
			if (Plugin.DebugLoggingEnabled.Value && _culledComponents.Count > 0)
			{
				Plugin.Log.LogInfo((object)$"[DistanceCuller] Collected {_culledComponents.Count} components on {((Object)((Component)this).gameObject).name}");
			}
		}

		public void ManagerUpdate(IReadOnlyList<Player> players)
		{
			if (players == null || players.Count == 0)
			{
				if (_isCulled)
				{
					SetComponentsEnabled(enabled: true);
				}
			}
			else
			{
				float minPlayerDistanceSqr = GetMinPlayerDistanceSqr(players);
				bool shouldCull = DetermineCullingState(minPlayerDistanceSqr);
				ApplyOwnershipLogic(shouldCull);
			}
		}

		private float GetMinPlayerDistanceSqr(IReadOnlyList<Player> players)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			float num = float.MaxValue;
			Vector3 position = _transform.position;
			for (int i = 0; i < players.Count; i++)
			{
				Player val = players[i];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).transform == (Object)null))
				{
					Vector3 val2 = ((Component)val).transform.position - position;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
					}
				}
			}
			return num;
		}

		private bool DetermineCullingState(float distSqr)
		{
			if (!_isCulled)
			{
				return distSqr > _cullDistanceSqr;
			}
			return distSqr > _wakeUpDistanceSqr;
		}

		private void ApplyOwnershipLogic(bool shouldCull)
		{
			if ((Object)(object)_zNetView == (Object)null)
			{
				return;
			}
			if (_zNetView.IsOwner())
			{
				if (_isCulled != shouldCull)
				{
					SetComponentsEnabled(!shouldCull);
				}
			}
			else if (_isCulled)
			{
				SetComponentsEnabled(enabled: true);
			}
		}

		private void SetComponentsEnabled(bool enabled)
		{
			if (_isCulled == !enabled)
			{
				return;
			}
			_isCulled = !enabled;
			if (!_isCharacter)
			{
				if (enabled)
				{
					EnableComponents();
				}
				else
				{
					DisableComponents();
				}
			}
		}

		private void EnableComponents()
		{
			for (int num = _culledComponents.Count - 1; num >= 0; num--)
			{
				MonoBehaviour val = _culledComponents[num];
				if ((Object)(object)val == (Object)null)
				{
					_culledComponents.RemoveAt(num);
				}
				else if (!((Behaviour)val).enabled)
				{
					try
					{
						((Behaviour)val).enabled = true;
					}
					catch (Exception ex)
					{
						if (Plugin.DebugLoggingEnabled.Value)
						{
							Plugin.Log.LogWarning((object)("[DistanceCuller] Failed to enable " + ((object)val).GetType().Name + ": " + ex.Message));
						}
					}
				}
			}
		}

		private void DisableComponents()
		{
			for (int num = _culledComponents.Count - 1; num >= 0; num--)
			{
				MonoBehaviour val = _culledComponents[num];
				if ((Object)(object)val == (Object)null)
				{
					_culledComponents.RemoveAt(num);
				}
				else if (((Behaviour)val).enabled)
				{
					try
					{
						((Behaviour)val).enabled = false;
					}
					catch (Exception ex)
					{
						if (Plugin.DebugLoggingEnabled.Value)
						{
							Plugin.Log.LogWarning((object)("[DistanceCuller] Failed to disable " + ((object)val).GetType().Name + ": " + ex.Message));
						}
					}
				}
			}
		}

		private void OnDestroy()
		{
			try
			{
				DistanceCullerManager.Instance?.UnregisterCuller(this);
				_culledComponents.Clear();
			}
			catch (Exception ex)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogError((object)("[DistanceCuller] OnDestroy error: " + ex.Message));
				}
			}
		}
	}
	public class DistanceCullerManager : MonoBehaviour
	{
		private static readonly List<Player> _globalPlayerCache = new List<Player>();

		private readonly List<DistanceCuller> _cullers = new List<DistanceCuller>(1024);

		private readonly HashSet<DistanceCuller> _cullerSet = new HashSet<DistanceCuller>();

		private float _playerUpdateTimer;

		private float _sliceTimer;

		private int _currentIndex;

		private const float PLAYER_UPDATE_INTERVAL = 1f;

		private const int MAX_CHECKS_PER_FRAME = 100;

		private Vector3 _lastPlayerPos;

		public static DistanceCullerManager Instance { get; private set; }

		public static IReadOnlyList<Player> Players => _globalPlayerCache;

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			Plugin.Log.LogInfo((object)"[DistanceCullerManager] Initialized with Time-Slicing.");
		}

		public void RegisterCuller(DistanceCuller culler)
		{
			if ((Object)(object)culler != (Object)null && _cullerSet.Add(culler))
			{
				_cullers.Add(culler);
			}
		}

		public void UnregisterCuller(DistanceCuller culler)
		{
			if (!((Object)(object)culler == (Object)null) && _cullerSet.Remove(culler))
			{
				int num = _cullers.IndexOf(culler);
				if (num >= 0)
				{
					int index = _cullers.Count - 1;
					_cullers[num] = _cullers[index];
					_cullers.RemoveAt(index);
				}
			}
		}

		private void Update()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			_playerUpdateTimer += Time.deltaTime;
			_sliceTimer += Time.deltaTime;
			if (_playerUpdateTimer >= 1f)
			{
				_playerUpdateTimer = 0f;
				_globalPlayerCache.Clear();
				List<Player> allPlayers = Player.GetAllPlayers();
				if (allPlayers != null)
				{
					_globalPlayerCache.AddRange(allPlayers);
				}
			}
			if (_sliceTimer < 0.1f)
			{
				return;
			}
			_sliceTimer = 0f;
			if (!Plugin.DistanceCullerEnabled.Value || _globalPlayerCache.Count == 0 || _cullers.Count == 0)
			{
				return;
			}
			if (_globalPlayerCache.Count == 1)
			{
				Player val = _globalPlayerCache[0];
				if ((Object)(object)val != (Object)null)
				{
					if (Vector3.SqrMagnitude(((Component)val).transform.position - _lastPlayerPos) < 1f)
					{
						return;
					}
					_lastPlayerPos = ((Component)val).transform.position;
				}
			}
			int num = _cullers.Count;
			int num2 = 0;
			while (num2 < 100 && num > 0)
			{
				if (_currentIndex >= num)
				{
					_currentIndex = 0;
				}
				DistanceCuller distanceCuller = _cullers[_currentIndex];
				if ((Object)(object)distanceCuller == (Object)null)
				{
					_cullerSet.Remove(distanceCuller);
					_cullers.RemoveAt(_currentIndex);
					num--;
				}
				else
				{
					distanceCuller.ManagerUpdate(_globalPlayerCache);
					_currentIndex++;
					num2++;
				}
			}
		}

		private void OnDestroy()
		{
			_cullers.Clear();
			_cullerSet.Clear();
			Instance = null;
		}
	}
	[HarmonyPatch]
	public static class GraphicsPatches
	{
		private static readonly FieldInfo _heightmapsListField = AccessTools.Field(typeof(Heightmap), "s_heightmaps");

		[HarmonyPatch(typeof(GameCamera), "Awake")]
		[HarmonyPostfix]
		private static void ApplyPostProcessingSettings(GameCamera __instance)
		{
			if (!Plugin.GraphicsSettingsEnabled.Value)
			{
				return;
			}
			PostProcessingBehaviour component = ((Component)__instance).GetComponent<PostProcessingBehaviour>();
			if (!((Object)(object)component == (Object)null) && !((Object)(object)component.profile == (Object)null))
			{
				PostProcessingProfile profile = component.profile;
				((PostProcessingModel)profile.bloom).enabled = Plugin.ConfigBloom.Value;
				((PostProcessingModel)profile.screenSpaceReflection).enabled = Plugin.ConfigReflections.Value;
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)"[Graphics] Applied post-processing settings.");
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		[HarmonyPostfix]
		private static void ApplyInitialTerrainSettings()
		{
			if (!Plugin.GraphicsSettingsEnabled.Value || _heightmapsListField == null || !(_heightmapsListField.GetValue(null) is List<Heightmap> list))
			{
				return;
			}
			if (Plugin.DebugLoggingEnabled.Value)
			{
				Plugin.Log.LogInfo((object)$"[Graphics] Applying terrain quality to {list.Count} existing heightmaps...");
			}
			float num = Mathf.Clamp(Plugin.ConfigTerrainQuality.Value, 0.1f, 2f);
			float heightmapPixelError = 5f / num;
			foreach (Heightmap item in list)
			{
				if ((Object)(object)item != (Object)null)
				{
					Terrain component = ((Component)item).GetComponent<Terrain>();
					if ((Object)(object)component != (Object)null)
					{
						component.heightmapPixelError = heightmapPixelError;
					}
				}
			}
		}
	}
	public static class AnimatorOptimizer
	{
		[HarmonyPatch(typeof(Character), "Awake")]
		public static class Character_Awake_Patch
		{
			[HarmonyPostfix]
			private static void Postfix(Character __instance)
			{
				if (!((Object)(object)__instance == (Object)null) && Plugin.AnimatorOptimizationEnabled.Value && (Object)(object)((Component)__instance).GetComponent<CharacterAnimatorOptimizer>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<CharacterAnimatorOptimizer>();
				}
			}
		}
	}
	public class CharacterAnimatorOptimizer : MonoBehaviour
	{
		private Character _character;

		private Animator _animator;

		private ZNetView _nview;

		private MonsterAI _monsterAI;

		private float _checkTimer;

		private const float CHECK_INTERVAL = 1f;

		private const float CULL_DIST_SQR = 3600f;

		private const float FAR_CULL_DIST_SQR = 10000f;

		private bool _isFullyCulled;

		private bool _isPartiallyCulled;

		private void Awake()
		{
			_character = ((Component)this).GetComponent<Character>();
			_animator = ((Component)this).GetComponent<Animator>();
			_nview = ((Component)this).GetComponent<ZNetView>();
			_monsterAI = ((Component)this).GetComponent<MonsterAI>();
			_checkTimer = Random.Range(0f, 1f);
		}

		private void FixedUpdate()
		{
			_checkTimer += Time.fixedDeltaTime;
			if (!(_checkTimer < 1f))
			{
				_checkTimer = 0f;
				Optimize();
			}
		}

		private void Optimize()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_character == (Object)null || (Object)(object)_animator == (Object)null)
			{
				Object.Destroy((Object)(object)this);
			}
			else
			{
				if (_character.IsPlayer() || ((Object)(object)_nview != (Object)null && !_nview.IsValid()) || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return;
				}
				Vector3 val = ((Component)_character).transform.position - ((Component)Player.m_localPlayer).transform.position;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude > 10000f)
				{
					bool flag = (Object)(object)_monsterAI != (Object)null && (Object)(object)((BaseAI)_monsterAI).GetTargetCreature() == (Object)(object)Player.m_localPlayer;
					if (!_isFullyCulled && !flag)
					{
						((Behaviour)_animator).enabled = false;
						_isFullyCulled = true;
						_isPartiallyCulled = false;
						if (Plugin.DebugLoggingEnabled.Value)
						{
							Plugin.Log.LogInfo((object)("[Animator] Fully disabled: " + ((Object)_character).name + " " + $"at {Mathf.Sqrt(sqrMagnitude):F1}m"));
						}
					}
				}
				else if (sqrMagnitude > 3600f)
				{
					if (!_isPartiallyCulled || _isFullyCulled)
					{
						((Behaviour)_animator).enabled = true;
						_animator.cullingMode = (AnimatorCullingMode)2;
						_isPartiallyCulled = true;
						_isFullyCulled = false;
						if (Plugin.DebugLoggingEnabled.Value)
						{
							Plugin.Log.LogInfo((object)("[Animator] CullCompletely: " + ((Object)_character).name + " " + $"at {Mathf.Sqrt(sqrMagnitude):F1}m"));
						}
					}
				}
				else if (_isPartiallyCulled || _isFullyCulled)
				{
					((Behaviour)_animator).enabled = true;
					_animator.cullingMode = (AnimatorCullingMode)0;
					_isPartiallyCulled = false;
					_isFullyCulled = false;
					if (Plugin.DebugLoggingEnabled.Value)
					{
						Plugin.Log.LogInfo((object)("[Animator] Full animation: " + ((Object)_character).name + " " + $"at {Mathf.Sqrt(sqrMagnitude):F1}m"));
					}
				}
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)_animator != (Object)null)
			{
				((Behaviour)_animator).enabled = true;
				_animator.cullingMode = (AnimatorCullingMode)0;
			}
		}
	}
	[HarmonyPatch]
	public static class MinimapOptimizer
	{
		private static FieldInfo _smallRootField;

		private static FieldInfo _largeRootField;

		private static bool _fieldsReady;

		private const int PIN_UPDATE_INTERVAL = 4;

		static MinimapOptimizer()
		{
			_smallRootField = AccessTools.Field(typeof(Minimap), "m_smallRoot") ?? AccessTools.Field(typeof(Minimap), "m_smallMapPanel");
			_largeRootField = AccessTools.Field(typeof(Minimap), "m_largeRoot") ?? AccessTools.Field(typeof(Minimap), "m_largeMapPanel");
			_fieldsReady = _smallRootField != null && _largeRootField != null;
			if (!_fieldsReady)
			{
				Plugin.Log.LogWarning((object)"[MinimapOptimizer] Minimap root fields not found — minimap update optimization disabled.");
			}
		}

		[HarmonyPatch(typeof(Minimap), "Update")]
		[HarmonyPrefix]
		private static bool Minimap_Update_Prefix(Minimap __instance)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			if (!Plugin.MinimapOptimizationEnabled.Value)
			{
				return true;
			}
			if (!_fieldsReady)
			{
				return true;
			}
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return true;
			}
			if ((int)__instance.m_mode == 2)
			{
				return true;
			}
			if ((int)__instance.m_mode == 0)
			{
				return false;
			}
			if ((int)__instance.m_mode == 1)
			{
				object? value = _smallRootField.GetValue(__instance);
				GameObject val = (GameObject)((value is GameObject) ? value : null);
				if ((Object)(object)val != (Object)null && !val.activeInHierarchy)
				{
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(Minimap), "UpdateDynamicPins")]
		[HarmonyPrefix]
		private static bool UpdateDynamicPins_Prefix(Minimap __instance)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			if (!Plugin.MinimapOptimizationEnabled.Value)
			{
				return true;
			}
			if ((int)__instance.m_mode == 0)
			{
				return false;
			}
			if ((int)__instance.m_mode == 2)
			{
				return true;
			}
			return Time.frameCount % 4 == 0;
		}
	}
}
namespace ValheimPerformanceOverhaul.UI
{
	[HarmonyPatch]
	public static class VPOSettingsMenu
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__4_0;

			public static Func<KeyValuePair<ConfigDefinition, ConfigEntryBase>, ConfigEntryBase> <>9__5_0;

			public static Func<ConfigEntryBase, string> <>9__5_1;

			public static Func<IGrouping<string, ConfigEntryBase>, int> <>9__5_2;

			public static Func<IGrouping<string, ConfigEntryBase>, string> <>9__5_3;

			internal void <OpenMenu>b__4_0()
			{
				((BaseUnityPlugin)Plugin.Instance).Config.Save();
				ToggleSettingsMenu();
			}

			internal ConfigEntryBase <GenerateConfigUI>b__5_0(KeyValuePair<ConfigDefinition, ConfigEntryBase> kvp)
			{
				return kvp.Value;
			}

			internal string <GenerateConfigUI>b__5_1(ConfigEntryBase x)
			{
				return x.Definition.Section;
			}

			internal int <GenerateConfigUI>b__5_2(IGrouping<string, ConfigEntryBase> x)
			{
				Match match = Regex.Match(x.Key, "^\\d+");
				if (!match.Success)
				{
					return 999;
				}
				return int.Parse(match.Value);
			}

			internal string <GenerateConfigUI>b__5_3(IGrouping<string, ConfigEntryBase> x)
			{
				return x.Key;
			}
		}

		private static GameObject _settingsCanvas;

		private static bool _isMenuOpen;

		[HarmonyPatch(typeof(FejdStartup), "Start")]
		[HarmonyPostfix]
		public static void AddMainMenuButton(FejdStartup __instance)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			Transform val = Utils.FindChild(((Component)__instance).transform, "Menu", (IterativeSearchType)0);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Transform val2 = Utils.FindChild(val, "Settings", (IterativeSearchType)0);
			if (!((Object)(object)val2 == (Object)null))
			{
				GameObject obj = Object.Instantiate<GameObject>(((Component)val2).gameObject, ((Component)__instance).transform);
				((Object)obj).name = "Button_VPOSettings";
				RectTransform component = obj.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(1f, 1f);
				component.anchorMax = new Vector2(1f, 1f);
				component.pivot = new Vector2(1f, 1f);
				component.sizeDelta = new Vector2(350f, component.sizeDelta.y);
				component.anchoredPosition = new Vector2(-20f, -20f);
				Text componentInChildren = obj.GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = "ValheimPerformanceOverhaul";
					componentInChildren.fontSize = 18;
					componentInChildren.horizontalOverflow = (HorizontalWrapMode)1;
				}
				Button component2 = obj.GetComponent<Button>();
				component2.onClick = new ButtonClickedEvent();
				((UnityEvent)component2.onClick).AddListener(new UnityAction(ToggleSettingsMenu));
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)"[VPOSettingsMenu] Top-Right button injected successfully.");
				}
			}
		}

		public static void ToggleSettingsMenu()
		{
			_isMenuOpen = !_isMenuOpen;
			if (_isMenuOpen)
			{
				OpenMenu();
			}
			else
			{
				CloseMenu();
			}
		}

		private static void OpenMenu()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_043d: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Expected O, but got Unknown
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			if ((Object)(object)_settingsCanvas != (Object)null)
			{
				return;
			}
			_settingsCanvas = new GameObject("VPOSettingsCanvas");
			_settingsCanvas.layer = 5;
			Object.DontDestroyOnLoad((Object)(object)_settingsCanvas);
			Canvas obj = _settingsCanvas.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 10000;
			_settingsCanvas.AddComponent<CanvasScaler>();
			_settingsCanvas.AddComponent<GraphicRaycaster>();
			GameObject val = MakeRect("Background", _settingsCanvas.transform, new Color(0.05f, 0.05f, 0.05f, 0.98f));
			SetRect(val, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(800f, 650f), Vector2.zero);
			Outline obj2 = val.AddComponent<Outline>();
			((Shadow)obj2).effectColor = new Color(0.3f, 0.3f, 0.3f, 1f);
			((Shadow)obj2).effectDistance = new Vector2(2f, -2f);
			SetRect(((Component)MakeText("Header", val.transform, "VPO CONFIGURATION", 26, new Color(1f, 0.7f, 0.2f), (FontStyle)1)).gameObject, new Vector2(0f, 0.9f), new Vector2(1f, 1f), Vector2.zero, new Vector2(0f, -10f));
			GameObject val2 = MakeRect("CloseBtn", val.transform, new Color(0.7f, 0.2f, 0.2f, 1f));
			SetRect(val2, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f), new Vector2(250f, 45f), new Vector2(0f, 35f));
			MakeText("CloseTxt", val2.transform, "CLOSE & SAVE", 18, Color.white, (FontStyle)1);
			ButtonClickedEvent onClick = val2.AddComponent<Button>().onClick;
			object obj3 = <>c.<>9__4_0;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					((BaseUnityPlugin)Plugin.Instance).Config.Save();
					ToggleSettingsMenu();
				};
				<>c.<>9__4_0 = val3;
				obj3 = (object)val3;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj3);
			GameObject val4 = MakeRect("ScrollArea", val.transform, new Color(0f, 0f, 0f, 0.6f));
			SetRect(val4, new Vector2(0.02f, 0.15f), new Vector2(0.98f, 0.88f), Vector2.zero, Vector2.zero);
			GameObject val5 = MakeRect("Scrollbar", val4.transform, new Color(0.1f, 0.1f, 0.1f, 1f));
			SetRect(val5, new Vector2(1f, 0f), new Vector2(1f, 1f), new Vector2(15f, 0f), new Vector2(-5f, 0f));
			val5.GetComponent<RectTransform>().pivot = new Vector2(1f, 0.5f);
			GameObject val6 = MakeRect("Handle", val5.transform, new Color(0.4f, 0.4f, 0.4f, 1f));
			SetRect(val6, Vector2.zero, Vector2.one, new Vector2(-4f, -4f), Vector2.zero);
			Scrollbar val7 = val5.AddComponent<Scrollbar>();
			val7.handleRect = val6.GetComponent<RectTransform>();
			val7.direction = (Direction)2;
			GameObject val8 = MakeRect("Viewport", val4.transform, new Color(1f, 1f, 1f, 0.01f));
			SetRect(val8, Vector2.zero, Vector2.one, new Vector2(-25f, 0f), new Vector2(-12.5f, 0f));
			val8.AddComponent<RectMask2D>();
			GameObject obj4 = MakeRect("Content", val8.transform, Color.clear);
			RectTransform component = obj4.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.sizeDelta = new Vector2(0f, 0f);
			VerticalLayoutGroup obj5 = obj4.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj5).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj5).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj5).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj5).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj5).spacing = 8f;
			((LayoutGroup)obj5).padding = new RectOffset(15, 15, 15, 15);
			obj4.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			ScrollRect obj6 = val4.AddComponent<ScrollRect>();
			obj6.content = component;
			obj6.viewport = val8.GetComponent<RectTransform>();
			obj6.horizontal = false;
			obj6.vertical = true;
			obj6.movementType = (MovementType)2;
			obj6.scrollSensitivity = 120f;
			obj6.verticalScrollbar = val7;
			obj6.verticalScrollbarVisibility = (ScrollbarVisibility)0;
			GenerateConfigUI(obj4.transform);
		}

		private static void GenerateConfigUI(Transform contentParent)
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			foreach (IGrouping<string, ConfigEntryBase> item in (from kvp in (IEnumerable<KeyValuePair<ConfigDefinition, ConfigEntryBase>>)((BaseUnityPlugin)Plugin.Instance).Config
				select kvp.Value into x
				group x by x.Definition.Section).OrderBy(delegate(IGrouping<string, ConfigEntryBase> x)
			{
				Match match = Regex.Match(x.Key, "^\\d+");
				return (!match.Success) ? 999 : int.Parse(match.Value);
			}).ThenBy((IGrouping<string, ConfigEntryBase> x) => x.Key))
			{
				Text obj = MakeText("Cat_" + item.Key, contentParent, "  " + item.Key.ToUpper(), 18, new Color(0.4f, 0.8f, 1f), (FontStyle)1);
				obj.alignment = (TextAnchor)3;
				LayoutElement obj2 = ((Component)obj).gameObject.AddComponent<LayoutElement>();
				obj2.minHeight = 35f;
				obj2.preferredHeight = 35f;
				foreach (ConfigEntryBase item2 in item)
				{
					GameObject val = MakeRect("Row_" + item2.Definition.Key, contentParent, new Color(1f, 1f, 1f, 0.05f));
					LayoutElement obj3 = val.AddComponent<LayoutElement>();
					obj3.minHeight = 40f;
					obj3.preferredHeight = 40f;
					HorizontalLayoutGroup obj4 = val.AddComponent<HorizontalLayoutGroup>();
					((HorizontalOrVerticalLayoutGroup)obj4).childControlWidth = true;
					((HorizontalOrVerticalLayoutGroup)obj4).childControlHeight = true;
					((HorizontalOrVerticalLayoutGroup)obj4).childForceExpandWidth = false;
					((HorizontalOrVerticalLayoutGroup)obj4).childForceExpandHeight = true;
					((HorizontalOrVerticalLayoutGroup)obj4).spacing = 15f;
					((LayoutGroup)obj4).padding = new RectOffset(15, 15, 5, 5);
					Text obj5 = MakeText("Label", val.transform, item2.Definition.Key, 15, Color.white, (FontStyle)0);
					obj5.alignment = (TextAnchor)3;
					((Component)obj5).gameObject.AddComponent<LayoutElement>().flexibleWidth = 1f;
					string text = "";
					if (item2.DefaultValue != null)
					{
						text = ((!(item2.SettingType == typeof(bool))) ? item2.DefaultValue.ToString() : (((bool)item2.DefaultValue) ? "ENABLED" : "DISABLED"));
					}
					Text obj6 = MakeText("DefLabel", val.transform, "(Def: " + text + ")", 13, new Color(0.5f, 0.5f, 0.5f, 1f), (FontStyle)0);
					obj6.alignment = (TextAnchor)5;
					LayoutElement obj7 = ((Component)obj6).gameObject.AddComponent<LayoutElement>();
					obj7.minWidth = 100f;
					obj7.preferredWidth = 120f;
					obj7.flexibleWidth = 0f;
					if (item2.SettingType == typeof(bool))
					{
						CreateBoolToggle(val.transform, (ConfigEntry<bool>)(object)item2);
					}
					else if (item2.SettingType == typeof(float) || item2.SettingType == typeof(int) || item2.SettingType == typeof(string))
					{
						CreateInputField(val.transform, item2);
					}
					else
					{
						((Component)MakeText("Unsupported", val.transform, "-", 15, Color.gray, (FontStyle)0)).gameObject.AddComponent<LayoutElement>().minWidth = 150f;
					}
				}
			}
		}

		private static void CreateBoolToggle(Transform parent, ConfigEntry<bool> entry)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			GameObject btnGo = MakeRect("ToggleBtn", parent, entry.Value ? new Color(0.2f, 0.6f, 0.2f) : new Color(0.6f, 0.2f, 0.2f));
			LayoutElement obj = btnGo.AddComponent<LayoutElement>();
			obj.minWidth = 150f;
			obj.preferredWidth = 150f;
			obj.flexibleWidth = 0f;
			Text txt = MakeText("Txt", btnGo.transform, entry.Value ? "ENABLED" : "DISABLED", 15, Color.white, (FontStyle)1);
			((UnityEvent)btnGo.AddComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				entry.Value = !entry.Value;
				((Graphic)btnGo.GetComponent<Image>()).color = (entry.Value ? new Color(0.2f, 0.6f, 0.2f) : new Color(0.6f, 0.2f, 0.2f));
				txt.text = (entry.Value ? "ENABLED" : "DISABLED");
			});
		}

		private static void CreateInputField(Transform parent, ConfigEntryBase entry)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = MakeRect("InputBg", parent, new Color(0f, 0f, 0f, 0.8f));
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.minWidth = 150f;
			obj.preferredWidth = 150f;
			obj.flexibleWidth = 0f;
			string text = ((entry.BoxedValue != null) ? entry.BoxedValue.ToString() : "");
			Text textComponent = MakeText("Text", val.transform, text, 15, Color.white, (FontStyle)0);
			InputField inputField = val.AddComponent<InputField>();
			inputField.textComponent = textComponent;
			inputField.text = text;
			if (entry.SettingType == typeof(int))
			{
				inputField.contentType = (ContentType)2;
			}
			else if (entry.SettingType == typeof(float))
			{
				inputField.contentType = (ContentType)3;
			}
			else
			{
				inputField.contentType = (ContentType)0;
			}
			((UnityEvent<string>)(object)inputField.onEndEdit).AddListener((UnityAction<string>)delegate(string text2)
			{
				float result2;
				if (entry.SettingType == typeof(int) && int.TryParse(text2, out var result))
				{
					entry.BoxedValue = result;
				}
				else if (entry.SettingType == typeof(float) && float.TryParse(text2, NumberStyles.Any, CultureInfo.InvariantCulture, out result2))
				{
					entry.BoxedValue = result2;
				}
				else if (entry.SettingType == typeof(string))
				{
					entry.BoxedValue = text2;
				}
				else
				{
					inputField.text = entry.BoxedValue?.ToString() ?? "";
				}
			});
		}

		private static void CloseMenu()
		{
			if ((Object)(object)_settingsCanvas != (Object)null)
			{
				Object.Destroy((Object)(object)_settingsCanvas);
				_settingsCanvas = null;
			}
			_isMenuOpen = false;
		}

		private static GameObject MakeRect(string name, Transform parent, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			GameObject val = new GameObject(name)
			{
				layer = 5
			};
			val.transform.SetParent(parent, false);
			((Graphic)val.AddComponent<Image>()).color = color;
			return val;
		}

		private static Text MakeText(string name, Transform parent, string text, int size, Color color, FontStyle style = (FontStyle)0)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.layer = 5;
			val.transform.SetParent(parent, false);
			Text obj = val.AddComponent<Text>();
			obj.text = text;
			obj.font = GetValheimFont();
			obj.fontSize = size;
			((Graphic)obj).color = color;
			obj.fontStyle = style;
			obj.alignment = (TextAnchor)4;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.sizeDelta = Vector2.zero;
			component.anchoredPosition = Vector2.zero;
			return obj;
		}

		private static void SetRect(GameObject go, Vector2 anchorMin, Vector2 anchorMax, Vector2 sizeDelta, Vector2 anchoredPos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMin = anchorMin;
			component.anchorMax = anchorMax;
			component.sizeDelta = sizeDelta;
			component.anchoredPosition = anchoredPos;
		}

		private static Font GetValheimFont()
		{
			Font[] array = Object.FindObjectsByType<Font>((FindObjectsSortMode)0);
			foreach (Font val in array)
			{
				if ((Object)(object)val != (Object)null && ((Object)val).name.Contains("Averia"))
				{
					return val;
				}
			}
			return Resources.GetBuiltinResource<Font>("Arial.ttf");
		}
	}
	public static class WelcomeMessage
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__2_0;

			internal void <ShowWelcomePanel>b__2_0()
			{
				Application.OpenURL("https://discord.com/users/1084209564653727804");
			}
		}

		private static bool _shown = false;

		private static readonly string PREFS_KEY = "VPO_HideWelcome_v2.7.0";

		[HarmonyPatch(typeof(FejdStartup), "Start")]
		[HarmonyPostfix]
		public static void ShowWelcomePanel()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_048e: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0502: Unknown result type (might be due to invalid IL or missing references)
			//IL_050c: Expected O, but got Unknown
			//IL_052b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0543: Unknown result type (might be due to invalid IL or missing references)
			//IL_0552: Unknown result type (might be due to invalid IL or missing references)
			//IL_0561: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d6: Expected O, but got Unknown
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Expected O, but got Unknown
			if (_shown || PlayerPrefs.GetInt(PREFS_KEY, 0) == 1)
			{
				return;
			}
			_shown = true;
			GameObject canvasGO = new GameObject("WelcomeCanvas_VPO");
			canvasGO.layer = 5;
			Canvas obj = canvasGO.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 9999;
			canvasGO.AddComponent<CanvasScaler>();
			canvasGO.AddComponent<GraphicRaycaster>();
			Object.DontDestroyOnLoad((Object)(object)canvasGO);
			GameObject val = MakeRect("Background", canvasGO.transform, new Color(0.05f, 0.05f, 0.05f, 0.96f));
			RectTransform component = val.GetComponent<RectTransform>();
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.sizeDelta = new Vector2(550f, 480f);
			component.anchoredPosition = Vector2.zero;
			GameObject val3 = MakeRect("Header", val.transform, new Color(0.1f, 0.1f, 0.1f, 1f));
			Stretch(val3, new Vector2(0f, 0.86f), Vector2.one);
			MakeText("Title", val3.transform, "ValheimPerformanceOverhaul", 22, new Color(1f, 0.85f, 0.4f), (FontStyle)1);
			Text obj2 = MakeText("Body", val.transform, "Hi! Thank you for using my mod.\nThe mod is in beta, so I'd love to hear any feedback:\nbugs, suggestions, logs - anything.\n\nПривет! Спасибо за использование моего мода.\nМод находится в бете, поэтому я буду рад любым отзывам:\nбагам, предложениям, логам - чему угодно.\n\nMy Discord account / Мой аккаунт Discord:", 15, Color.white, (FontStyle)0);
			obj2.lineSpacing = 1.2f;
			obj2.alignment = (TextAnchor)1;
			SetAnchors(((Component)obj2).gameObject, new Vector2(0f, 0.35f), new Vector2(1f, 0.86f), new Vector2(20f, 0f), new Vector2(-20f, -15f));
			GameObject val4 = MakeRect("Link", val.transform, Color.clear);
			SetAnchors(val4, new Vector2(0f, 0.25f), new Vector2(1f, 0.35f), new Vector2(20f, 0f), new Vector2(-20f, 0f));
			MakeText("LinkText", val4.transform, "https://discord.com/users/1084209564653727804 (skarif_q)", 15, new Color(0.35f, 0.7f, 1f), (FontStyle)0);
			RectTransform component2 = MakeRect("Underline", val4.transform, new Color(0.35f, 0.7f, 1f)).GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.05f, 0f);
			component2.anchorMax = new Vector2(0.95f, 0f);
			component2.sizeDelta = new Vector2(0f, 1.5f);
			component2.anchoredPosition = new Vector2(0f, 3f);
			Image component3 = val4.GetComponent<Image>();
			Color highlight = new Color(0.35f, 0.7f, 1f, 0.15f);
			Color pressed = new Color(0.35f, 0.7f, 1f, 0.3f);
			object obj3 = <>c.<>9__2_0;
			if (obj3 == null)
			{
				UnityAction val5 = delegate
				{
					Application.OpenURL("https://discord.com/users/1084209564653727804");
				};
				<>c.<>9__2_0 = val5;
				obj3 = (object)val5;
			}
			MakeButton(val4, component3, highlight, pressed, (UnityAction)obj3);
			MakeSeparator("Sep1", val.transform, 0.22f);
			MakeSeparator("Sep2", val.transform, 0.14f);
			bool dontShow = false;
			SetPivotAnchor(((Component)MakeText("Label", val.transform, "Don't show anymore / Больше не показывать", 13, new Color(0.75f, 0.75f, 0.75f), (FontStyle)0)).gameObject, new Vector2(0.5f, 0f), new Vector2(280f, 30f), new Vector2(20f, 85f));
			GameObject val6 = MakeRect("Box", val.transform, new Color(0.25f, 0.25f, 0.25f, 1f));
			SetPivotAnchor(val6, new Vector2(0.5f, 0f), new Vector2(18f, 18f), new Vector2(-135f, 85f));
			GameObject tickGO = ((Component)MakeText("Tick", val6.transform, "v", 13, new Color(0.35f, 0.7f, 1f), (FontStyle)1)).gameObject;
			tickGO.SetActive(false);
			GameObject obj4 = MakeRect("CheckHit", val.transform, Color.clear);
			SetPivotAnchor(obj4, new Vector2(0.5f, 0f), new Vector2(320f, 30f), new Vector2(0f, 85f));
			Image boxImg = val6.GetComponent<Image>();
			MakeButton(obj4, obj4.GetComponent<Image>(), new Color(1f, 1f, 1f, 0.05f), new Color(1f, 1f, 1f, 0.1f), (UnityAction)delegate
			{
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				dontShow = !dontShow;
				tickGO.SetActive(dontShow);
				((Graphic)boxImg).color = (dontShow ? new Color(0.1f, 0.25f, 0.45f, 1f) : new Color(0.25f, 0.25f, 0.25f, 1f));
			});
			GameObject val7 = MakeRect("Close", val.transform, new Color(0.65f, 0.15f, 0.15f, 1f));
			SetPivotAnchor(val7, new Vector2(0.5f, 0f), new Vector2(140f, 34f), new Vector2(0f, 20f));
			MakeText("CloseText", val7.transform, "Close / Закрыть", 15, Color.white, (FontStyle)0);
			MakeButton(val7, val7.GetComponent<Image>(), new Color(0.85f, 0.25f, 0.25f, 1f), new Color(0.45f, 0.08f, 0.08f, 1f), (UnityAction)delegate
			{
				if (dontShow)
				{
					PlayerPrefs.SetInt(PREFS_KEY, 1);
				}
				Object.Destroy((Object)(object)canvasGO);
			});
		}

		private static GameObject MakeRect(string name, Transform parent, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			GameObject val = new GameObject(name)
			{
				layer = 5
			};
			val.transform.SetParent(parent, false);
			val.AddComponent<RectTransform>();
			((Graphic)val.AddComponent<Image>()).color = color;
			return val;
		}

		private static Text MakeText(string name, Transform parent, string text, int size, Color color, FontStyle style = (FontStyle)0)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.layer = 5;
			val.transform.SetParent(parent, false);
			val.AddComponent<RectTransform>();
			Text obj = val.AddComponent<Text>();
			obj.text = text;
			obj.font = GetFont();
			obj.fontSize = size;
			((Graphic)obj).color = color;
			obj.fontStyle = style;
			obj.alignment = (TextAnchor)4;
			Stretch(val, Vector2.zero, Vector2.one);
			return obj;
		}

		private static void MakeButton(GameObject go, Image target, Color highlight, Color pressed, UnityAction action)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Button obj = go.AddComponent<Button>();
			((Selectable)obj).targetGraphic = (Graphic)(object)target;
			ColorBlock colors = ((Selectable)obj).colors;
			((ColorBlock)(ref colors)).normalColor = ((Graphic)target).color;
			((ColorBlock)(ref colors)).highlightedColor = highlight;
			((ColorBlock)(ref colors)).pressedColor = pressed;
			((Selectable)obj).colors = colors;
			((UnityEvent)obj.onClick).AddListener(action);
		}

		private static void MakeSeparator(string name, Transform parent, float anchorY)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = MakeRect(name, parent, new Color(1f, 1f, 1f, 0.12f)).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, anchorY);
			component.anchorMax = new Vector2(1f, anchorY);
			component.sizeDelta = new Vector2(0f, 1f);
			component.anchoredPosition = Vector2.zero;
		}

		private static void Stretch(GameObject go, Vector2 min, Vector2 max)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMin = min;
			component.anchorMax = max;
			Vector2 offsetMin = (component.offsetMax = Vector2.zero);
			component.offsetMin = offsetMin;
		}

		private static void SetAnchors(GameObject go, Vector2 min, Vector2 max, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			component.anchorMin = min;
			component.anchorMax = max;
			component.offsetMin = offsetMin;
			component.offsetMax = offsetMax;
		}

		private static void SetPivotAnchor(GameObject go, Vector2 anchor, Vector2 size, Vector2 pos)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = go.GetComponent<RectTransform>();
			Vector2 anchorMin = (component.anchorMax = anchor);
			component.anchorMin = anchorMin;
			component.sizeDelta = size;
			component.anchoredPosition = pos;
		}

		private static Font GetFont()
		{
			Font[] array = Object.FindObjectsByType<Font>((FindObjectsSortMode)0);
			foreach (Font val in array)
			{
				if ((Object)(object)val != (Object)null && ((Object)val).name.Contains("Averia"))
				{
					return val;
				}
			}
			return Resources.GetBuiltinResource<Font>("Arial.ttf");
		}
	}
}
namespace ValheimPerformanceOverhaul.ObjectPooling
{
	[HarmonyPatch]
	public static class ObjectPoolingPatches
	{
		private static readonly HashSet<string> _projectileWhitelist;

		private static readonly HashSet<int> _whitelistHashes;

		private const string CloneSuffix = "(Clone)";

		public static IEnumerable<string> Whitelist => _projectileWhitelist;

		static ObjectPoolingPatches()
		{
			_projectileWhitelist = new HashSet<string> { "vfx_arrowhit", "vfx_BloodHit", "vfx_HitSparks" };
			_whitelistHashes = new HashSet<int>(_projectileWhitelist.Count);
			foreach (string item in _projectileWhitelist)
			{
				_whitelistHashes.Add(StringExtensionMethods.GetStableHashCode(item));
			}
		}

		public static bool IsInWhitelist(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (_whitelistHashes.Contains(stableHashCode))
			{
				return true;
			}
			int num = name.IndexOf("(Clone)", StringComparison.Ordinal);
			if (num < 0)
			{
				return false;
			}
			string text = name.Substring(0, num).Trim();
			return _whitelistHashes.Contains(StringExtensionMethods.GetStableHashCode(text));
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[HarmonyPostfix]
		private static void OnZNetSceneAwake()
		{
			if (Plugin.ObjectPoolingEnabled.Value)
			{
				ObjectPoolManager.Initialize();
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		[HarmonyPostfix]
		private static void PrewarmOnSpawn(Player __instance)
		{
			if (Plugin.ObjectPoolingEnabled.Value && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				ObjectPoolManager.PrewarmPool("vfx_arrowhit", 15);
				ObjectPoolManager.PrewarmPool("vfx_BloodHit", 15);
				ObjectPoolManager.PrewarmPool("vfx_HitSparks", 10);
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Destroy")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool ZNetDestroyPrefix(GameObject go)
		{
			if (!Plugin.ObjectPoolingEnabled.Value || (Object)(object)go == (Object)null)
			{
				return true;
			}
			if (!ObjectPoolManager.IsPooled(go))
			{
				return true;
			}
			if (ObjectPoolManager.IsTracked(go))
			{
				ObjectPoolManager.ReturnObject(go);
			}
			return false;
		}

		[HarmonyPatch(typeof(Object), "Destroy", new Type[] { typeof(Object) })]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool ObjectDestroyPrefix(Object obj)
		{
			if (!Plugin.ObjectPoolingEnabled.Value || obj == (Object)null)
			{
				return true;
			}
			GameObject val = (GameObject)(object)((obj is GameObject) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			if (!ObjectPoolManager.IsPooled(val))
			{
				return true;
			}
			if (ObjectPoolManager.IsTracked(val))
			{
				ObjectPoolManager.ReturnObject(val);
			}
			return false;
		}

		[HarmonyPatch(typeof(Object), "Destroy", new Type[]
		{
			typeof(Object),
			typeof(float)
		})]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool ObjectDestroyDelayPrefix(Object obj, float t)
		{
			if (!Plugin.ObjectPoolingEnabled.Value || obj == (Object)null)
			{
				return true;
			}
			if (t > 0f)
			{
				return true;
			}
			GameObject val = (GameObject)(object)((obj is GameObject) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			if (!ObjectPoolManager.IsPooled(val))
			{
				return true;
			}
			if (ObjectPoolManager.IsTracked(val))
			{
				ObjectPoolManager.ReturnObject(val);
			}
			return false;
		}

		[HarmonyPatch(typeof(Projectile), "SpawnOnHit")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpile_Projectile_SpawnOnHit(IEnumerable<CodeInstruction> instructions)
		{
			return PatchInstantiate(instructions, "Projectile.SpawnOnHit");
		}

		private static IEnumerable<CodeInstruction> PatchInstantiate(IEnumerable<CodeInstruction> instructions, string methodName)
		{
			MethodInfo poolMethod = AccessTools.Method(typeof(ObjectPoolManager), "InstantiateFromPool", (Type[])null, (Type[])null);
			int patched = 0;
			foreach (CodeInstruction instruction in instructions)
			{
				if ((instruction.opcode == OpCodes.Call || instruction.opcode == OpCodes.Callvirt) && instruction.operand is MethodInfo { Name: "Instantiate" } methodInfo && IsGameObjectInstantiate(methodInfo))
				{
					patched++;
					yield return new CodeInstruction(OpCodes.Call, (object)poolMethod);
				}
				else
				{
					yield return instruction;
				}
			}
			if (patched > 0)
			{
				Plugin.Log.LogInfo((object)$"[ObjectPooling] Transpiler OK: {patched} Instantiate(s) patched in {methodName}");
			}
			else
			{
				Plugin.Log.LogWarning((object)("[ObjectPooling] Transpiler MISS: Instantiate not found in " + methodName));
			}
		}

		private static bool IsGameObjectInstantiate(MethodInfo mi)
		{
			if (mi.GetParameters().Length != 3)
			{
				return false;
			}
			if (mi.ReturnType == typeof(GameObject))
			{
				return true;
			}
			Type[] genericArguments = mi.GetGenericArguments();
			if (genericArguments.Length != 0)
			{
				return genericArguments[0] == typeof(GameObject);
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		[HarmonyPostfix]
		private static void ClearPoolOnShutdown()
		{
			ObjectPoolManager.Clear();
		}
	}
	public static class ObjectPoolManager
	{
		private static readonly Dictionary<int, Queue<GameObject>> _pools;

		private static readonly HashSet<GameObject> _objectsInUse;

		private static readonly HashSet<GameObject> _allPooledObjects;

		private static Transform _poolParent;

		private const int MAX_POOL_SIZE = 50;

		private static readonly FieldInfo _fldDidHit;

		private static readonly FieldInfo _fldVel;

		private static readonly FieldInfo _fldDidBounce;

		private static readonly FieldInfo _fldBounceCount;

		private static readonly FieldInfo _fldHaveStartPoint;

		private static readonly FieldInfo _fldStartPoint;

		private static readonly FieldInfo _fldChangedVisual;

		private static readonly FieldInfo _fldAttachParent;

		private static readonly FieldInfo _fldHasLeftShields;

		private static readonly FieldInfo _fldOwner;

		private static readonly FieldInfo _fldSkill;

		private static readonly FieldInfo _fldDamage;

		private static readonly FieldInfo _fldTtl;

		private static readonly FieldInfo _fldRaiseSkill;

		private static readonly FieldInfo _fldWeapon;

		private static readonly FieldInfo _fldAmmo;

		private static readonly FieldInfo _fldOrigHitData;

		private static readonly Action<Projectile, bool> _setDidHit;

		private static readonly Action<Projectile, bool> _setDidBounce;

		private static readonly Action<Projectile, bool> _setHaveStartPoint;

		private static readonly Action<Projectile, bool> _setChangedVisual;

		private static readonly Action<Projectile, bool> _setHasLeftShields;

		private static readonly Action<Projectile, Vector3> _setVel;

		private static readonly Action<Projectile, Vector3> _setStartPoint;

		private static readonly Action<Projectile, int> _setBounceCount;

		private static readonly Action<Projectile, float> _setTtl;

		private static readonly Action<Projectile, float> _setRaiseSkill;

		private static readonly Action<Projectile, object> _setAttachParent;

		private static readonly Action<Projectile, object> _setOwner;

		private static readonly Action<Projectile, object> _setWeapon;

		private static readonly Action<Projectile, object> _setAmmo;

		private static readonly Action<Projectile, SkillType> _setSkill;

		private static readonly Action<Projectile, object> _setDamage;

		private static readonly Action<Projectile, object> _setOrigHitData;

		private static readonly object _defaultDamageTypes;

		private static readonly object _defaultHitData;

		private static FieldInfo FindField(Type type, string name)
		{
			return type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}

		private static Action<TObj, TVal> BuildSetter<TObj, TVal>(FieldInfo fi)
		{
			if (fi == null)
			{
				return null;
			}
			try
			{
				ParameterExpression parameterExpression = Expression.Parameter(typeof(TObj), "obj");
				ParameterExpression parameterExpression2 = Expression.Parameter(typeof(TVal), "val");
				MemberExpression left = Expression.Field(parameterExpression, fi);
				Expression right = ((typeof(TVal) == typeof(object)) ? ((Expression)Expression.Convert(parameterExpression2, fi.FieldType)) : ((Expression)parameterExpression2));
				return Expression.Lambda<Action<TObj, TVal>>(Expression.Assign(left, right), new ParameterExpression[2] { parameterExpression, parameterExpression2 }).Compile();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[ObjectPooling] BuildSetter failed for " + fi.Name + ": " + ex.Message));
				return null;
			}
		}

		static ObjectPoolManager()
		{
			_pools = new Dictionary<int, Queue<GameObject>>();
			_objectsInUse = new HashSet<GameObject>();
			_allPooledObjects = new HashSet<GameObject>();
			_fldDidHit = FindField(typeof(Projectile), "m_didHit");
			_fldVel = FindField(typeof(Projectile), "m_vel");
			_fldDidBounce = FindField(typeof(Projectile), "m_didBounce");
			_fldBounceCount = FindField(typeof(Projectile), "m_bounceCount");
			_fldHaveStartPoint = FindField(typeof(Projectile), "m_haveStartPoint");
			_fldStartPoint = FindField(typeof(Projectile), "m_startPoint");
			_fldChangedVisual = FindField(typeof(Projectile), "m_changedVisual");
			_fldAttachParent = FindField(typeof(Projectile), "m_attachParent");
			_fldHasLeftShields = FindField(typeof(Projectile), "m_hasLeftShields");
			_fldOwner = FindField(typeof(Projectile), "m_owner");
			_fldSkill = FindField(typeof(Projectile), "m_skill");
			_fldDamage = FindField(typeof(Projectile), "m_damage");
			_fldTtl = FindField(typeof(Projectile), "m_ttl");
			_fldRaiseSkill = FindField(typeof(Projectile), "m_raiseSkillAmount");
			_fldWeapon = FindField(typeof(Projectile), "m_weapon");
			_fldAmmo = FindField(typeof(Projectile), "m_ammo");
			_fldOrigHitData = FindField(typeof(Projectile), "m_originalHitData");
			_setDidHit = BuildSetter<Projectile, bool>(_fldDidHit);
			_setDidBounce = BuildSetter<Projectile, bool>(_fldDidBounce);
			_setHaveStartPoint = BuildSetter<Projectile, bool>(_fldHaveStartPoint);
			_setChangedVisual = BuildSetter<Projectile, bool>(_fldChangedVisual);
			_setHasLeftShields = BuildSetter<Projectile, bool>(_fldHasLeftShields);
			_setVel = BuildSetter<Projectile, Vector3>(_fldVel);
			_setStartPoint = BuildSetter<Projectile, Vector3>(_fldStartPoint);
			_setBounceCount = BuildSetter<Projectile, int>(_fldBounceCount);
			_setTtl = BuildSetter<Projectile, float>(_fldTtl);
			_setRaiseSkill = BuildSetter<Projectile, float>(_fldRaiseSkill);
			_setAttachParent = BuildSetter<Projectile, object>(_fldAttachParent);
			_setOwner = BuildSetter<Projectile, object>(_fldOwner);
			_setWeapon = BuildSetter<Projectile, object>(_fldWeapon);
			_setAmmo = BuildSetter<Projectile, object>(_fldAmmo);
			_setSkill = BuildSetter<Projectile, SkillType>(_fldSkill);
			_setDamage = BuildSetter<Projectile, object>(_fldDamage);
			_setOrigHitData = BuildSetter<Projectile, object>(_fldOrigHitData);
			_defaultDamageTypes = ((_fldDamage != null) ? Activator.CreateInstance(_fldDamage.FieldType) : null);
			_defaultHitData = ((_fldOrigHitData != null) ? Activator.CreateInstance(_fldOrigHitData.FieldType) : null);
		}

		public static void Initialize()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if (!((Object)(object)_poolParent != (Object)null))
			{
				GameObject val = new GameObject("_VPO_ProjectilePool");
				_poolParent = val.transform;
				Object.DontDestroyOnLoad((Object)val);
				_pools.Clear();
				_objectsInUse.Clear();
				_allPooledObjects.Clear();
				Warn(_fldDidHit, "m_didHit");
				Warn(_fldVel, "m_vel");
				Warn(_fldOwner, "m_owner");
				Warn(_fldDamage, "m_damage");
				Warn(_fldTtl, "m_ttl");
				Warn(_fldSkill, "m_skill");
				Warn(_fldStartPoint, "m_startPoint");
				Plugin.Log.LogInfo((object)"[ObjectPooling] Pool initialized.");
			}
			static void Warn(FieldInfo fi, string name)
			{
				if (fi == null)
				{
					Plugin.Log.LogWarning((object)("[ObjectPooling] FieldInfo not found: Projectile." + name));
				}
			}
		}

		public static void Clear()
		{
			List<GameObject> list = new List<GameObject>(_allPooledObjects.Where((GameObject o) => (Object)(object)o != (Object)null));
			_allPooledObjects.Clear();
			_objectsInUse.Clear();
			foreach (Queue<GameObject> value in _pools.Values)
			{
				value.Clear();
			}
			_pools.Clear();
			foreach (GameObject item in list)
			{
				Object.Destroy((Object)(object)item);
			}
			if ((Object)(object)_poolParent != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_poolParent).gameObject);
				_poolParent = null;
			}
			Plugin.Log.LogInfo((object)"[ObjectPooling] Pool cleared.");
		}

		public static void PrewarmPool(string prefabName, int count)
		{
			if ((Object)(object)ZNetScene.instance == (Object)null || (Object)(object)_poolParent == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[ObjectPooling] PrewarmPool aborted '" + prefabName + "': not ready."));
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(prefabName);
			if ((Object)(object)prefab == (Object)null)
			{
				Plugin.Log.LogWarning((object)("[ObjectPooling] Prefab not found: " + prefabName));
				return;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(prefabName);
			if (!_pools.ContainsKey(stableHashCode))
			{
				_pools[stableHashCode] = new Queue<GameObject>();
			}
			int num = count - _pools[stableHashCode].Count;
			if (num > 0)
			{
				for (int i = 0; i < num; i++)
				{
					GameObject val = Object.Instantiate<GameObject>(prefab, _poolParent);
					((Object)val).name = ((Object)prefab).name;
					val.SetActive(false);
					val.AddComponent<PooledObject>().PrewarmSetup(prefabName);
					_pools[stableHashCode].Enqueue(val);
					_allPooledObjects.Add(val);
				}
				Plugin.Log.LogInfo((object)($"[ObjectPooling] Prewarmed {num} of '{prefabName}'. " + $"Total tracked: {_allPooledObjects.Count}"));
			}
		}

		public static GameObject InstantiateFromPool(GameObject original, Vector3 position, Quaternion rotation)
		{
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)original == (Object)null)
			{
				return null;
			}
			if (ObjectPoolingPatches.IsInWhitelist(((Object)original).name))
			{
				if (TryGetObject(((Object)original).name, out var instance))
				{
					instance.transform.position = position;
					instance.transform.rotation = rotation;
					instance.SetActive(true);
					if (Plugin.DebugLoggingEnabled.Value)
					{
						Plugin.Log.LogInfo((object)$"[ObjectPooling] REUSED: {((Object)original).name} (in use: {_objectsInUse.Count})");
					}
					return instance;
				}
				GameObject val = Object.Instantiate<GameObject>(original, position, rotation);
				((Object)val).name = ((Object)original).name;
				val.AddComponent<PooledObject>().Initialize(((Object)original).name);
				_objectsInUse.Add(val);
				_allPooledObjects.Add(val);
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)$"[ObjectPooling] CREATED (pool empty): {((Object)original).name} (in use: {_objectsInUse.Count})");
				}
				return val;
			}
			return Object.Instantiate<GameObject>(original, position, rotation);
		}

		private static bool TryGetObject(string prefabName, out GameObject instance)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(prefabName);
			instance = null;
			GameObject val = null;
			if (_pools.TryGetValue(stableHashCode, out var value))
			{
				while (value.Count > 0)
				{
					val = value.Dequeue();
					if ((Object)(object)val == (Object)null || val.activeSelf || _objectsInUse.Contains(val))
					{
						val = null;
						continue;
					}
					_objectsInUse.Add(val);
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			PooledObject component = val.GetComponent<PooledObject>();
			if ((Object)(object)component != (Object)null)
			{
				component.Initialize(prefabName);
			}
			ResetObjectState(val, component);
			instance = val;
			return true;
		}

		public static void ReturnObject(GameObject instance)
		{
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			if ((Object)(object)_poolParent == (Object)null)
			{
				Object.Destroy((Object)(object)instance);
				return;
			}
			PooledObject component = instance.GetComponent<PooledObject>();
			if (_objectsInUse.Contains(instance))
			{
				int key = (((Object)(object)component != (Object)null) ? component.PrefabHash : StringExtensionMethods.GetStableHashCode(((Object)instance).name.Replace("(Clone)", "").Trim()));
				CleanupObjectState(instance, component);
				instance.SetActive(false);
				instance.transform.SetParent(_poolParent);
				_objectsInUse.Remove(instance);
				component?.MarkAsAvailable();
				if (!_pools.TryGetValue(key, out var value))
				{
					value = new Queue<GameObject>();
					_pools.Add(key, value);
				}
				if (value.Count < 50)
				{
					value.Enqueue(instance);
					return;
				}
				_allPooledObjects.Remove(instance);
				Object.Destroy((Object)(object)instance);
			}
		}

		private static void CleanupObjectState(GameObject instance, PooledObject pooled)
		{
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)pooled != (Object)null)
			{
				if (pooled.CachedRigidbodies != null)
				{
					Rigidbody[] cachedRigidbodies = pooled.CachedRigidbodies;
					foreach (Rigidbody val in cachedRigidbodies)
					{
						if ((Object)(object)val != (Object)null && !val.isKinematic)
						{
							val.velocity = Vector3.zero;
							val.angularVelocity = Vector3.zero;
							val.Sleep();
						}
					}
				}
				if (pooled.CachedParticles != null)
				{
					ParticleSystem[] cachedParticles = pooled.CachedParticles;
					foreach (ParticleSystem val2 in cachedParticles)
					{
						if ((Object)(object)val2 != (Object)null)
						{
							val2.Stop(true, (ParticleSystemStopBehavior)0);
						}
					}
				}
				if (pooled.CachedAudios != null)
				{
					AudioSource[] cachedAudios = pooled.CachedAudios;
					foreach (AudioSource val3 in cachedAudios)
					{
						if ((Object)(object)val3 != (Object)null && val3.isPlaying)
						{
							val3.Stop();
						}
					}
				}
				if (pooled.CachedTrails != null)
				{
					TrailRenderer[] cachedTrails = pooled.CachedTrails;
					foreach (TrailRenderer val4 in cachedTrails)
					{
						if ((Object)(object)val4 != (Object)null)
						{
							val4.Clear();
						}
					}
				}
			}
			instance.transform.position = new Vector3(0f, -10000f, 0f);
		}

		private static void ResetObjectState(GameObject instance, PooledObject pooled)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)pooled != (Object)null)
			{
				if (pooled.CachedRigidbodies != null)
				{
					Rigidbody[] cachedRigidbodies = pooled.CachedRigidbodies;
					foreach (Rigidbody val in cachedRigidbodies)
					{
						if ((Object)(object)val != (Object)null && !val.isKinematic)
						{
							val.WakeUp();
						}
					}
				}
				if (pooled.CachedTrails != null)
				{
					TrailRenderer[] cachedTrails = pooled.CachedTrails;
					foreach (TrailRenderer val2 in cachedTrails)
					{
						if ((Object)(object)val2 != (Object)null)
						{
							val2.Clear();
						}
					}
				}
			}
			Projectile val3 = (((Object)(object)pooled != (Object)null && (Object)(object)pooled.CachedProjectile != (Object)null) ? pooled.CachedProjectile : instance.GetComponent<Projectile>());
			if (!((Object)(object)val3 == (Object)null))
			{
				_setDidHit?.Invoke(val3, arg2: false);
				_setVel?.Invoke(val3, Vector3.zero);
				_setDidBounce?.Invoke(val3, arg2: false);
				_setBounceCount?.Invoke(val3, 0);
				_setHaveStartPoint?.Invoke(val3, arg2: false);
				_setStartPoint?.Invoke(val3, Vector3.zero);
				_setChangedVisual?.Invoke(val3, arg2: false);
				_setHasLeftShields?.Invoke(val3, arg2: false);
				_setAttachParent?.Invoke(val3, null);
				_setOwner?.Invoke(val3, null);
				_setSkill?.Invoke(val3, (SkillType)0);
				_setRaiseSkill?.Invoke(val3, 0f);
				_setWeapon?.Invoke(val3, null);
				_setAmmo?.Invoke(val3, null);
				if (_setDamage != null && _defaultDamageTypes != null)
				{
					_setDamage(val3, _defaultDamageTypes);
				}
				if (_setOrigHitData != null && _defaultHitData != null)
				{
					_setOrigHitData(val3, _defaultHitData);
				}
			}
		}

		public static void PerformMaintenance()
		{
			_allPooledObjects.RemoveWhere((GameObject obj) => (Object)(object)obj == (Object)null);
			List<GameObject> list = null;
			foreach (GameObject item in _objectsInUse)
			{
				if ((Object)(object)item != (Object)null && !item.activeSelf)
				{
					if (list == null)
					{
						list = new List<GameObject>();
					}
					list.Add(item);
				}
			}
			if (list != null)
			{
				foreach (GameObject item2 in list)
				{
					ReturnObject(item2);
				}
			}
			List<int> list2 = new List<int>();
			foreach (KeyValuePair<int, Queue<GameObject>> pool in _pools)
			{
				bool flag = false;
				foreach (GameObject item3 in pool.Value)
				{
					if ((Object)(object)item3 == (Object)null)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					list2.Add(pool.Key);
				}
			}
			foreach (int item4 in list2)
			{
				if (!_pools.TryGetValue(item4, out var value))
				{
					continue;
				}
				int count = value.Count;
				for (int num = 0; num < count; num++)
				{
					GameObject val = value.Dequeue();
					if ((Object)(object)val != (Object)null)
					{
						value.Enqueue(val);
					}
				}
			}
		}

		public static void LogPoolStats()
		{
			if (!Plugin.DebugLoggingEnabled.Value)
			{
				return;
			}
			int num = 0;
			foreach (Queue<GameObject> value in _pools.Values)
			{
				num += value.Count;
			}
			Plugin.Log.LogInfo((object)($"[ObjectPooling] Stats — In use: {_objectsInUse.Count}, " + $"Pooled: {num}, Types: {_pools.Count}, " + $"Total tracked: {_allPooledObjects.Count}"));
		}

		public static bool IsPooled(GameObject instance)
		{
			return _allPooledObjects.Contains(instance);
		}

		public static bool IsTracked(GameObject instance)
		{
			return _objectsInUse.Contains(instance);
		}
	}
	public class PooledObject : MonoBehaviour
	{
		public int PrefabHash { get; private set; }

		public bool IsInUse { get; private set; }

		public int UseCount { get; private set; }

		public Rigidbody[] CachedRigidbodies { get; private set; }

		public ParticleSystem[] CachedParticles { get; private set; }

		public AudioSource[] CachedAudios { get; private set; }

		public TrailRenderer[] CachedTrails { get; private set; }

		public ZNetView CachedZNetView { get; private set; }

		public Projectile CachedProjectile { get; private set; }

		private void Awake()
		{
			CachedRigidbodies = ((Component)this).GetComponentsInChildren<Rigidbody>(true);
			CachedParticles = ((Component)this).GetComponentsInChildren<ParticleSystem>(true);
			CachedAudios = ((Component)this).GetComponentsInChildren<AudioSource>(true);
			CachedTrails = ((Component)this).GetComponentsInChildren<TrailRenderer>(true);
			CachedZNetView = ((Component)this).GetComponent<ZNetView>();
			CachedProjectile = ((Component)this).GetComponent<Projectile>();
		}

		public void Initialize(string prefabName)
		{
			IsInUse = true;
			UseCount++;
			PrefabHash = StringExtensionMethods.GetStableHashCode(prefabName);
		}

		public void PrewarmSetup(string prefabName)
		{
			PrefabHash = StringExtensionMethods.GetStableHashCode(prefabName);
			IsInUse = false;
		}

		public void MarkAsAvailable()
		{
			IsInUse = false;
		}
	}
}
namespace ValheimPerformanceOverhaul.Vegetation
{
	[HarmonyPatch]
	public static class VegetationPatches
	{
		private static readonly FieldInfo _fDistance;

		private static readonly FieldInfo _fClutter;

		private static readonly Func<object, int> _getAmount;

		private static readonly Action<object, int> _setAmount;

		private static readonly bool _delegatesReady;

		static VegetationPatches()
		{
			_fDistance = AccessTools.Field(typeof(ClutterSystem), "m_distance");
			_fClutter = AccessTools.Field(typeof(ClutterSystem), "m_clutter");
			Type type = null;
			if (_fClutter != null)
			{
				Type fieldType = _fClutter.FieldType;
				if (fieldType.IsArray)
				{
					type = fieldType.GetElementType();
				}
				else if (fieldType.IsGenericType)
				{
					type = fieldType.GetGenericArguments()[0];
				}
			}
			if (type != null)
			{
				FieldInfo fieldInfo = AccessTools.Field(type, "m_amount");
				if (fieldInfo != null)
				{
					ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "inst");
					_getAmount = Expression.Lambda<Func<object, int>>(Expression.Field(Expression.Convert(parameterExpression, type), fieldInfo), new ParameterExpression[1] { parameterExpression }).Compile();
					ParameterExpression parameterExpression2 = Expression.Parameter(typeof(object), "inst");
					ParameterExpression parameterExpression3 = Expression.Parameter(typeof(int), "val");
					_setAmount = Expression.Lambda<Action<object, int>>(Expression.Assign(Expression.Field(Expression.Convert(parameterExpression2, type), fieldInfo), parameterExpression3), new ParameterExpression[2] { parameterExpression2, parameterExpression3 }).Compile();
					_delegatesReady = true;
				}
			}
			if (_fDistance == null)
			{
				Plugin.Log.LogWarning((object)"[Vegetation] ClutterSystem.m_distance not found — grass distance patch disabled.");
			}
			if (!_delegatesReady)
			{
				Plugin.Log.LogWarning((object)"[Vegetation] Clutter.m_amount delegates not built — grass density patch disabled.");
			}
		}

		[HarmonyPatch(typeof(ClutterSystem), "Awake")]
		[HarmonyPostfix]
		private static void ApplyGrassSettings(ClutterSystem __instance)
		{
			if (Plugin.VegetationOptimizationEnabled.Value)
			{
				ApplyDistance(__instance);
				ApplyDensity(__instance);
			}
		}

		private static void ApplyDistance(ClutterSystem instance)
		{
			if (_fDistance == null)
			{
				return;
			}
			try
			{
				float num = Plugin.GrassRenderDistance?.Value ?? 60f;
				_fDistance.SetValue(instance, num);
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)$"[Vegetation] Grass distance → {num}m");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[Vegetation] Failed to set grass distance: " + ex.Message));
			}
		}

		private static void ApplyDensity(ClutterSystem instance)
		{
			if (_fClutter == null || !_delegatesReady)
			{
				return;
			}
			try
			{
				float num = Plugin.GrassDensityMultiplier?.Value ?? 0.7f;
				if (!(_fClutter.GetValue(instance) is IList list))
				{
					return;
				}
				for (int i = 0; i < list.Count; i++)
				{
					object obj = list[i];
					if (obj != null)
					{
						int num2 = _getAmount(obj);
						int arg = Mathf.Max(1, Mathf.RoundToInt((float)num2 * num));
						_setAmount(obj, arg);
					}
				}
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)$"[Vegetation] Grass density → {num * 100f:F0}%");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[Vegetation] Failed to set grass density: " + ex.Message));
			}
		}

		[HarmonyPatch(typeof(Heightmap), "Awake")]
		[HarmonyPostfix]
		private static void OptimizeTerrainDetails(Heightmap __instance)
		{
			if (!Plugin.VegetationOptimizationEnabled.Value)
			{
				return;
			}
			try
			{
				Terrain component = ((Component)__instance).GetComponent<Terrain>();
				if (!((Object)(object)component == (Object)null))
				{
					component.detailObjectDistance = Plugin.DetailObjectDistance?.Value ?? 80f;
					component.detailObjectDensity = Plugin.DetailDensity?.Value ?? 0.7f;
					component.heightmapMaximumLOD = Plugin.TerrainMaxLOD?.Value ?? 1;
					if (Plugin.DebugLoggingEnabled.Value)
					{
						Plugin.Log.LogInfo((object)($"[Vegetation] Terrain: dist={component.detailObjectDistance}, " + $"density={component.detailObjectDensity}, LOD={component.heightmapMaximumLOD}"));
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[Vegetation] Failed to optimize terrain: " + ex.Message));
			}
		}
	}
}
namespace ValheimPerformanceOverhaul.Particles
{
	public class TrackedParticle : MonoBehaviour
	{
		private bool _wasPlaying;

		private bool _isCulled;

		public ParticleSystem System { get; private set; }

		public bool IsCulled => _isCulled;

		private void Awake()
		{
			System = ((Component)this).GetComponent<ParticleSystem>();
		}

		public void SetCulled(bool culled)
		{
			if ((Object)(object)System == (Object)null || _isCulled == culled)
			{
				return;
			}
			if (culled)
			{
				_wasPlaying = System.isPlaying;
				if (_wasPlaying)
				{
					System.Stop(true, (ParticleSystemStopBehavior)1);
				}
			}
			else if (_wasPlaying && !System.isPlaying)
			{
				System.Play(true);
			}
			_isCulled = culled;
		}
	}
	public class ParticleSystemManager : MonoBehaviour
	{
		private readonly List<TrackedParticle> _allParticles = new List<TrackedParticle>(1024);

		private readonly HashSet<TrackedParticle> _culledParticles = new HashSet<TrackedParticle>();

		private float _updateTimer;

		private int _cleanupCounter;

		private const float UPDATE_INTERVAL = 0.5f;

		private const int CLEANUP_EVERY_N = 10;

		private float _cullDistance = 50f;

		private int _maxActiveParticles = 30;

		public static ParticleSystemManager Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		private void Start()
		{
			_cullDistance = Plugin.ParticleCullDistance?.Value ?? 50f;
			_maxActiveParticles = Plugin.MaxActiveParticles?.Value ?? 30;
			ScanExistingParticles();
			Plugin.Log.LogInfo((object)$"[Particles] Initialized: {_allParticles.Count} systems tracked.");
		}

		private void ScanExistingParticles()
		{
			ParticleSystem[] array = Object.FindObjectsByType<ParticleSystem>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (ParticleSystem ps in array)
			{
				TryRegister(ps);
			}
		}

		public void RegisterParticleSystem(ParticleSystem ps)
		{
			TryRegister(ps);
		}

		private void TryRegister(ParticleSystem ps)
		{
			if (!((Object)(object)ps == (Object)null) && !((Object)(object)((Component)ps).GetComponent<TrackedParticle>() != (Object)null) && ((Component)ps).gameObject.layer != LayerMask.NameToLayer("UI") && !IsVehicleParticle(ps))
			{
				TrackedParticle item = ((Component)ps).gameObject.AddComponent<TrackedParticle>();
				_allParticles.Add(item);
			}
		}

		private static bool IsVehicleParticle(ParticleSystem ps)
		{
			if ((Object)(object)((Component)ps).GetComponentInParent<Ship>() != (Object)null)
			{
				return true;
			}
			string text = ((Object)((Component)ps).gameObject).name.ToLowerInvariant();
			string text2 = ((Object)((Component)ps).transform.root).name.ToLowerInvariant();
			if (!text.Contains("ship") && !text.Contains("vehicle") && !text.Contains("boat") && !text.Contains("karve") && !text2.Contains("ship") && !text2.Contains("vehicle") && !text2.Contains("boat"))
			{
				return text2.Contains("karve");
			}
			return true;
		}

		private void Update()
		{
			if (!Plugin.ParticleOptimizationEnabled.Value || (Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)Camera.main == (Object)null)
			{
				return;
			}
			_updateTimer += Time.deltaTime;
			if (!(_updateTimer < 0.5f))
			{
				_updateTimer = 0f;
				_cleanupCounter++;
				if (_cleanupCounter >= 10)
				{
					_cleanupCounter = 0;
					CleanupDeadParticles();
				}
				UpdateCulling();
			}
		}

		private void CleanupDeadParticles()
		{
			for (int num = _allParticles.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)_allParticles[num] == (Object)null || (Object)(object)_allParticles[num].System == (Object)null)
				{
					TrackedParticle trackedParticle = _allParticles[num];
					if ((Object)(object)trackedParticle != (Object)null)
					{
						_culledParticles.Remove(trackedParticle);
					}
					_allParticles.RemoveAt(num);
				}
			}
		}

		private void UpdateCulling()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if (_allParticles.Count == 0)
			{
				return;
			}
			Vector3 position = ((Component)Camera.main).transform.position;
			float num = _cullDistance * _cullDistance;
			int num2 = 0;
			for (int i = 0; i < _allParticles.Count; i++)
			{
				TrackedParticle trackedParticle = _allParticles[i];
				if ((Object)(object)trackedParticle == (Object)null || (Object)(object)trackedParticle.System == (Object)null)
				{
					continue;
				}
				Vector3 val = ((Component)trackedParticle).transform.position - position;
				if (((Vector3)(ref val)).sqrMagnitude <= num && num2 < _maxActiveParticles)
				{
					if (trackedParticle.IsCulled)
					{
						trackedParticle.SetCulled(culled: false);
						_culledParticles.Remove(trackedParticle);
					}
					num2++;
				}
				else if (!trackedParticle.IsCulled)
				{
					trackedParticle.SetCulled(culled: true);
					_culledParticles.Add(trackedParticle);
				}
			}
			if (Plugin.DebugLoggingEnabled.Value && Time.frameCount % 240 == 0)
			{
				Plugin.Log.LogInfo((object)$"[Particles] Active: {num2}/{_maxActiveParticles}, Culled: {_culledParticles.Count}, Total: {_allParticles.Count}");
			}
		}

		private void OnDestroy()
		{
			foreach (TrackedParticle culledParticle in _culledParticles)
			{
				if ((Object)(object)culledParticle != (Object)null)
				{
					culledParticle.SetCulled(culled: false);
				}
			}
			_allParticles.Clear();
			_culledParticles.Clear();
			Instance = null;
		}
	}
	[HarmonyPatch]
	public static class ParticlePatches
	{
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		[HarmonyPostfix]
		private static void InitParticleManager(Player __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			if (Plugin.ParticleOptimizationEnabled.Value && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && !((Object)(object)ParticleSystemManager.Instance != (Object)null))
			{
				GameObject val = new GameObject("_VPO_ParticleSystemManager");
				Object.DontDestroyOnLoad((Object)val);
				val.AddComponent<ParticleSystemManager>();
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "CreateObject")]
		[HarmonyPostfix]
		private static void OnObjectCreated(GameObject __result)
		{
			if (Plugin.ParticleOptimizationEnabled.Value && !((Object)(object)ParticleSystemManager.Instance == (Object)null) && !((Object)(object)__result == (Object)null))
			{
				ParticleSystem[] componentsInChildren = __result.GetComponentsInChildren<ParticleSystem>(true);
				foreach (ParticleSystem ps in componentsInChildren)
				{
					ParticleSystemManager.Instance.RegisterParticleSystem(ps);
				}
			}
		}
	}
}
namespace ValheimPerformanceOverhaul.Audio
{
	[HarmonyPatch]
	public static class AudioPatches
	{
		[HarmonyPatch(typeof(ZSFX), "Play")]
		[HarmonyPrefix]
		private static bool ZSFX_Play_Prefix(ZSFX __instance)
		{
			if (!Plugin.AudioPoolingEnabled.Value)
			{
				return true;
			}
			AudioSource component = ((Component)__instance).GetComponent<AudioSource>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			return !AudioPoolManager.TryPlayClip(component);
		}

		[HarmonyPatch(typeof(AudioSource), "Play", new Type[] { })]
		[HarmonyPrefix]
		private static bool AudioSource_Play_Prefix(AudioSource __instance)
		{
			if (!Plugin.AudioPoolingEnabled.Value)
			{
				return true;
			}
			if ((Object)(object)((Component)__instance).GetComponent<ZSFX>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)__instance).GetComponent<PooledAudio>() != (Object)null)
			{
				return true;
			}
			if (AudioPoolManager.ShouldSkip(__instance))
			{
				return true;
			}
			return !AudioPoolManager.TryPlayClip(__instance);
		}
	}
	public class PooledAudio : MonoBehaviour
	{
		private bool _isAvailable = true;

		private float _playStartTime;

		private float _clipLength;

		public AudioSource Source { get; private set; }

		public bool IsAvailable => _isAvailable;

		private void Awake()
		{
			Source = ((Component)this).GetComponent<AudioSource>();
		}

		public void CheckStatus()
		{
			if (!_isAvailable && !((Object)(object)Source == (Object)null))
			{
				float num = _playStartTime + _clipLength + 0.1f;
				if (Time.time >= num && !Source.isPlaying)
				{
					SetAvailable(available: true);
				}
			}
		}

		public void Play(AudioSource original)
		{
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Source == (Object)null) && !((Object)(object)original == (Object)null) && !((Object)(object)original.clip == (Object)null))
			{
				_isAvailable = false;
				_playStartTime = Time.time;
				float pitch = original.pitch;
				_clipLength = original.clip.length;
				if (Mathf.Abs(pitch) > 0.01f)
				{
					_clipLength /= Mathf.Abs(pitch);
				}
				Source.clip = original.clip;
				Source.volume = original.volume;
				Source.pitch = pitch;
				Source.loop = original.loop;
				Source.outputAudioMixerGroup = original.outputAudioMixerGroup;
				Source.priority = original.priority;
				float spatialBlend = original.spatialBlend;
				Source.spatialBlend = spatialBlend;
				if (spatialBlend > 0.01f)
				{
					Source.rolloffMode = original.rolloffMode;
					Source.minDistance = original.minDistance;
					Source.maxDistance = original.maxDistance;
					Source.spread = original.spread;
					Source.dopplerLevel = original.dopplerLevel;
				}
				((Component)Source).transform.position = ((Component)original).transform.position;
				Source.Play();
			}
		}

		public void SetAvailable(bool available)
		{
			if (_isAvailable == available)
			{
				return;
			}
			_isAvailable = available;
			if (available)
			{
				if ((Object)(object)Source != (Object)null)
				{
					Source.Stop();
					Source.clip = null;
				}
				AudioPoolManager.ReturnToPool(this);
			}
		}

		private void OnDestroy()
		{
			AudioSource source = Source;
			if (source != null)
			{
				source.Stop();
			}
		}
	}
	public class AudioPoolUpdateProxy : MonoBehaviour
	{
		private void Update()
		{
			AudioPoolManager.UpdateAllSources();
		}
	}
	public static class AudioPoolManager
	{
		private static readonly Stack<PooledAudio> _availablePool = new Stack<PooledAudio>();

		private static readonly HashSet<PooledAudio> _availableSet = new HashSet<PooledAudio>();

		private static readonly List<PooledAudio> _allSources = new List<PooledAudio>();

		private static GameObject _poolObject;

		private static bool _isInitialized;

		public static void Initialize()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			if (!_isInitialized)
			{
				_poolObject = new GameObject("_VPO_AudioPool");
				Object.DontDestroyOnLoad((Object)(object)_poolObject);
				_poolObject.AddComponent<AudioPoolUpdateProxy>();
				int num = Plugin.AudioPoolSize?.Value ?? 32;
				for (int i = 0; i < num; i++)
				{
					CreatePooledSource();
				}
				_isInitialized = true;
				Plugin.Log.LogInfo((object)$"[AudioPooling] Initialized {_allSources.Count} sources.");
			}
		}

		private static void CreatePooledSource()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject($"PooledAudio_{_allSources.Count}");
			val.transform.SetParent(_poolObject.transform);
			AudioSource obj = val.AddComponent<AudioSource>();
			obj.playOnAwake = false;
			obj.spatialBlend = 1f;
			PooledAudio item = val.AddComponent<PooledAudio>();
			_allSources.Add(item);
			_availablePool.Push(item);
			_availableSet.Add(item);
		}

		public static void UpdateAllSources()
		{
			for (int i = 0; i < _allSources.Count; i++)
			{
				_allSources[i].CheckStatus();
			}
		}

		public static bool TryPlayClip(AudioSource original)
		{
			if (!_isInitialized || (Object)(object)original == (Object)null || (Object)(object)original.clip == (Object)null)
			{
				return false;
			}
			if (ShouldSkip(original))
			{
				return false;
			}
			if (_availablePool.Count == 0)
			{
				return false;
			}
			PooledAudio pooledAudio = _availablePool.Pop();
			_availableSet.Remove(pooledAudio);
			pooledAudio.Play(original);
			return true;
		}

		public static bool ShouldSkip(AudioSource src)
		{
			if (src.spatialBlend < 0.1f)
			{
				return true;
			}
			if (src.loop)
			{
				return true;
			}
			if ((Object)(object)src.clip != (Object)null && src.clip.length > 10f)
			{
				return true;
			}
			if ((Object)(object)src.outputAudioMixerGroup != (Object)null)
			{
				string text = ((Object)src.outputAudioMixerGroup).name.ToLowerInvariant();
				if (text.Contains("music") || text.Contains("gui") || text.Contains("voice"))
				{
					return true;
				}
			}
			return false;
		}

		internal static void ReturnToPool(PooledAudio pooled)
		{
			if (!((Object)(object)pooled == (Object)null) && _availableSet.Add(pooled))
			{
				_availablePool.Push(pooled);
			}
		}

		public static void Shutdown()
		{
			_isInitialized = false;
			_availablePool.Clear();
			_availableSet.Clear();
			_allSources.Clear();
			if ((Object)(object)_poolObject != (Object)null)
			{
				Object.Destroy((Object)(object)_poolObject);
				_poolObject = null;
			}
		}
	}
}
namespace ValheimPerformanceOverhaul.LightCulling
{
	[HarmonyPatch]
	public static class LightCullingPatches
	{
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		[HarmonyPostfix]
		private static void AddLightManager_Postfix(Player __instance)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			if (Plugin.LightCullingEnabled.Value && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && !((Object)(object)AdvancedLightManager.Instance != (Object)null))
			{
				GameObject val = new GameObject("_VPO_AdvancedLightManager");
				Object.DontDestroyOnLoad((Object)val);
				val.AddComponent<AdvancedLightManager>();
				Plugin.Log.LogInfo((object)"[LightCulling] Advanced manager initialized.");
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "CreateObject")]
		[HarmonyPostfix]
		private static void OnObjectInstantiated_Postfix(GameObject __result)
		{
			if ((Object)(object)__result == (Object)null)
			{
				return;
			}
			bool flag = Plugin.LightCullingEnabled.Value && (Object)(object)AdvancedLightManager.Instance != (Object)null;
			bool flag2 = Plugin.LightCullingEnabled.Value && Plugin.LightLODEnabled.Value && (Object)(object)LightLODManager.Instance != (Object)null;
			if (!flag && !flag2)
			{
				return;
			}
			Light[] componentsInChildren = __result.GetComponentsInChildren<Light>(true);
			if (componentsInChildren == null || componentsInChildren.Length == 0)
			{
				return;
			}
			Light[] array = componentsInChildren;
			foreach (Light val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (flag)
					{
						AdvancedLightManager.Instance.TryRegisterLight(val);
					}
					if (flag2)
					{
						LightLODManager.Instance.RegisterLight(val);
					}
				}
			}
		}
	}
	[HarmonyPatch]
	public static class LightLODPatches
	{
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		[HarmonyPostfix]
		private static void InitializeLightLOD(Player __instance)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			if (Plugin.LightCullingEnabled.Value && Plugin.LightLODEnabled.Value && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && !((Object)(object)LightLODManager.Instance != (Object)null))
			{
				GameObject val = new GameObject("_VPO_LightLODManager");
				Object.DontDestroyOnLoad((Object)val);
				val.AddComponent<LightLODManager>();
				Plugin.Log.LogInfo((object)"[LightLOD] System initialized.");
			}
		}
	}
	public enum LightLODLevel
	{
		Full,
		NoShadows,
		Emissive,
		Billboard,
		Disabled
	}
	public class LightLOD : MonoBehaviour
	{
		private MeshRenderer _meshRenderer;

		private Material _emissiveMaterial;

		private GameObject _billboardObject;

		private SpriteRenderer _billboardRenderer;

		private LightShadows _originalShadows;

		private Material _originalMaterial;

		private Color _lightColor;

		private TrackedLight _trackedLight;

		private LightLODLevel _currentLOD;

		private static Texture2D _glowTexture;

		private static Material _billboardMaterial;

		private static Shader _billboardShader;

		private static bool _sharedResourcesReady;

		public Light LightSource { get; private set; }

		public LightPriority Priority { get; private set; }

		public LightLODLevel CurrentLOD => _currentLOD;

		private void Awake()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			LightSource = ((Component)this).GetComponent<Light>();
			if (!((Object)(object)LightSource == (Object)null))
			{
				_originalShadows = LightSource.shadows;
				_lightColor = LightSource.color;
				_meshRenderer = ((Component)this).GetComponentInChildren<MeshRenderer>();
				if ((Object)(object)_meshRenderer != (Object)null)
				{
					_originalMaterial = ((Renderer)_meshRenderer).material;
				}
				_trackedLight = ((Component)this).GetComponent<TrackedLight>();
				DeterminePriority();
				EnsureSharedResources();
			}
		}

		private void DeterminePriority()
		{
			if ((Object)(object)LightSource == (Object)null)
			{
				Priority = LightPriority.VeryLow;
				return;
			}
			string text = (((Object)(object)((Component)this).transform.parent != (Object)null) ? ((Object)((Component)this).transform.parent).name.ToLower() : "");
			string text2 = ((Object)((Component)this).gameObject).name.ToLower();
			if ((Object)(object)((Component)((Component)this).transform.root).GetComponent<Player>() != (Object)null)
			{
				Priority = LightPriority.Critical;
			}
			else if (text.Contains("fire") || text.Contains("hearth"))
			{
				Priority = LightPriority.High;
			}
			else if (text.Contains("torch") || text2.Contains("torch"))
			{
				Priority = LightPriority.Medium;
			}
			else if (LightSource.intensity > 2f)
			{
				Priority = LightPriority.High;
			}
			else if (LightSource.intensity > 1f)
			{
				Priority = LightPriority.Medium;
			}
			else
			{
				Priority = LightPriority.Low;
			}
		}

		private static void EnsureSharedResources()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			if (!_sharedResourcesReady)
			{
				_glowTexture = CreateGlowTexture();
				((Object)_glowTexture).hideFlags = (HideFlags)52;
				_billboardShader = Shader.Find("Sprites/Default") ?? Shader.Find("Unlit/Transparent");
				if ((Object)(object)_billboardShader != (Object)null)
				{
					_billboardMaterial = new Material(_billboardShader);
					((Object)_billboardMaterial).hideFlags = (HideFlags)52;
					_billboardMaterial.mainTexture = (Texture)(object)_glowTexture;
					_billboardMaterial.SetInt("_ZWrite", 0);
					_billboardMaterial.renderQueue = 3000;
				}
				_sharedResourcesReady = true;
			}
		}

		private static Texture2D CreateGlowTexture()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false);
			Color[] array = (Color[])(object)new Color[1024];
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(16f, 16f);
			float num = 16f;
			for (int i = 0; i < 32; i++)
			{
				for (int j = 0; j < 32; j++)
				{
					float num2 = Vector2.Distance(new Vector2((float)j, (float)i), val2);
					float num3 = Mathf.Pow(Mathf.Clamp01(1f - num2 / num), 2f);
					array[i * 32 + j] = new Color(1f, 1f, 1f, num3);
				}
			}
			val.SetPixels(array);
			val.Apply();
			((Texture)val).wrapMode = (TextureWrapMode)1;
			((Texture)val).filterMode = (FilterMode)1;
			return val;
		}

		private void CreateBillboard()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_billboardObject != (Object)null) && _sharedResourcesReady)
			{
				_billboardObject = new GameObject("LightBillboard");
				_billboardObject.transform.SetParent(((Component)this).transform);
				_billboardObject.transform.localPosition = Vector3.zero;
				_billboardRenderer = _billboardObject.AddComponent<SpriteRenderer>();
				Sprite sprite = Sprite.Create(_glowTexture, new Rect(0f, 0f, (float)((Texture)_glowTexture).width, (float)((Texture)_glowTexture).height), new Vector2(0.5f, 0.5f));
				_billboardRenderer.sprite = sprite;
				((Renderer)_billboardRenderer).material = _billboardMaterial;
				_billboardRenderer.color = _lightColor;
				float num = (((Object)(object)LightSource != (Object)null) ? LightSource.range : 5f);
				float num2 = Mathf.Lerp(0.5f, 2f, Mathf.Clamp01(num / 15f));
				_billboardObject.transform.localScale = Vector3.one * num2;
				_billboardObject.SetActive(false);
			}
		}

		private void CreateEmissiveMaterial()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_meshRenderer == (Object)null) && !((Object)(object)_emissiveMaterial != (Object)null))
			{
				_emissiveMaterial = new Material(_originalMaterial);
				((Object)_emissiveMaterial).hideFlags = (HideFlags)52;
				_emissiveMaterial.EnableKeyword("_EMISSION");
				_emissiveMaterial.SetColor("_EmissionColor", _lightColor * 1.5f);
				if (!_emissiveMaterial.HasProperty("_EmissionColor"))
				{
					_emissiveMaterial.SetColor("_Color", _lightColor * 1.5f);
				}
			}
		}

		public void SetLODLevel(LightLODLevel level, bool cullingManagerActive = false)
		{
			if (_currentLOD != level && !((Object)(object)LightSource == (Object)null))
			{
				if (cullingManagerActive && level < LightLODLevel.Emissive)
				{
					level = LightLODLevel.Emissive;
				}
				DisableCurrentLOD(level);
				_currentLOD = level;
				switch (level)
				{
				case LightLODLevel.Full:
					EnableFullLight();
					break;
				case LightLODLevel.NoShadows:
					EnableLightNoShadows();
					break;
				case LightLODLevel.Emissive:
					EnableEmissive();
					break;
				case LightLODLevel.Billboard:
					EnableBillboard();
					break;
				}
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)$"[LightLOD] {((Object)((Component)this).gameObject).name} -> LOD {level}");
				}
			}
		}

		private void DisableCurrentLOD(LightLODLevel targetLevel)
		{
			if (_currentLOD == LightLODLevel.Full)
			{
				_ = 1;
			}
			else
				_ = _currentLOD == LightLODLevel.NoShadows;
			bool flag = targetLevel == LightLODLevel.Full || targetLevel == LightLODLevel.NoShadows;
			if ((Object)(object)LightSource != (Object)null && !flag)
			{
				((Behaviour)LightSource).enabled = false;
			}
			if ((Object)(object)_meshRenderer != (Object)null && (Object)(object)_originalMaterial != (Object)null)
			{
				((Renderer)_meshRenderer).material = _originalMaterial;
			}
			if ((Object)(object)_billboardObject != (Object)null)
			{
				_billboardObject.SetActive(false);
			}
		}

		private void EnableFullLight()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			((Behaviour)LightSource).enabled = true;
			LightSource.shadows = _originalShadows;
		}

		private void EnableLightNoShadows()
		{
			((Behaviour)LightSource).enabled = true;
			LightSource.shadows = (LightShadows)0;
		}

		private void EnableEmissive()
		{
			if (!((Object)(object)_meshRenderer == (Object)null))
			{
				if ((Object)(object)_emissiveMaterial == (Object)null)
				{
					CreateEmissiveMaterial();
				}
				if ((Object)(object)_emissiveMaterial != (Object)null)
				{
					((Renderer)_meshRenderer).material = _emissiveMaterial;
				}
			}
		}

		private void EnableBillboard()
		{
			if ((Object)(object)_billboardObject == (Object)null)
			{
				CreateBillboard();
			}
			if ((Object)(object)_billboardObject != (Object)null)
			{
				_billboardObject.SetActive(true);
			}
		}

		public void Cleanup()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)LightSource != (Object)null)
			{
				((Behaviour)LightSource).enabled = true;
				LightSource.shadows = _originalShadows;
			}
			if ((Object)(object)_meshRenderer != (Object)null && (Object)(object)_originalMaterial != (Object)null)
			{
				((Renderer)_meshRenderer).material = _originalMaterial;
			}
			if ((Object)(object)_billboardObject != (Object)null)
			{
				Object.Destroy((Object)(object)_billboardObject);
				_billboardObject = null;
			}
			if ((Object)(object)_emissiveMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)_emissiveMaterial);
				_emissiveMaterial = null;
			}
			_currentLOD = LightLODLevel.Full;
			Object.Destroy((Object)(object)this);
		}

		private void OnDestroy()
		{
			LightLODManager.Instance?.UnregisterLight(this);
			if ((Object)(object)_emissiveMaterial != (Object)null)
			{
				Object.Destroy((Object)(object)_emissiveMaterial);
			}
			if ((Object)(object)_billboardObject != (Object)null)
			{
				Object.Destroy((Object)(object)_billboardObject);
			}
		}
	}
	public class LightLODManager : MonoBehaviour
	{
		private const int MAX_TRACKED_LIGHTS = 512;

		private readonly HashSet<LightLOD> _lightSet = new HashSet<LightLOD>();

		private readonly List<LightLOD> _allLights = new List<LightLOD>(256);

		private float _updateTimer;

		private int _cleanupCounter;

		private const float UPDATE_INTERVAL = 0.5f;

		private float _fullLODDistance = 20f;

		private float _noShadowDistance = 40f;

		private float _emissiveDistance = 70f;

		private float _billboardDistance = 100f;

		public static LightLODManager Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else
			{
				Instance = this;
			}
		}

		private void Start()
		{
			LoadConfig();
			Plugin.Log.LogInfo((object)"[LightLOD] Manager initialized. Reactive registration active.");
		}

		private void LoadConfig()
		{
			_fullLODDistance = Plugin.LightLODFullDistance?.Value ?? 20f;
			_noShadowDistance = Plugin.LightLODNoShadowDistance?.Value ?? 40f;
			_emissiveDistance = Plugin.LightLODEmissiveDistance?.Value ?? 70f;
			_billboardDistance = Plugin.LightLODBillboardDistance?.Value ?? 100f;
		}

		public void RegisterLight(Light light)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if ((Object)(object)light == (Object)null || (int)light.type == 1)
			{
				return;
			}
			if (_allLights.Count >= 512)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogWarning((object)$"[LightLOD] Cap reached ({512}), skipping: {((Object)light).name}");
				}
				return;
			}
			LightLOD lightLOD = ((Component)light).GetComponent<LightLOD>();
			if ((Object)(object)lightLOD == (Object)null)
			{
				lightLOD = ((Component)light).gameObject.AddComponent<LightLOD>();
			}
			if (_lightSet.Add(lightLOD))
			{
				_allLights.Add(lightLOD);
			}
		}

		public void UnregisterLight(LightLOD lod)
		{
			if (!((Object)(object)lod == (Object)null) && _lightSet.Remove(lod))
			{
				_allLights.Remove(lod);
			}
		}

		private void Update()
		{
			if (!Plugin.LightCullingEnabled.Value || !Plugin.LightLODEnabled.Value)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)Camera.main == (Object)null)
				{
					return;
				}
				_updateTimer += Time.deltaTime;
				if (!(_updateTimer < 0.5f))
				{
					_updateTimer = 0f;
					_cleanupCounter++;
					if (_cleanupCounter >= 10)
					{
						_cleanupCounter = 0;
						CleanupNullLights();
					}
					UpdateLODs();
				}
			}
		}

		private void CleanupNullLights()
		{
			for (int num = _allLights.Count - 1; num >= 0; num--)
			{
				LightLOD lightLOD = _allLights[num];
				if (lightLOD == null || lightLOD == null || (Object)(object)lightLOD.LightSource == (Object)null)
				{
					if (lightLOD != null)
					{
						_lightSet.Remove(lightLOD);
					}
					_allLights.RemoveAt(num);
				}
			}
		}

		private void UpdateLODs()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)Camera.main).transform.position;
			for (int i = 0; i < _allLights.Count; i++)
			{
				LightLOD lightLOD = _allLights[i];
				if (!((Object)(object)lightLOD == (Object)null) && !((Object)(object)lightLOD.LightSource == (Object)null))
				{
					float num = Vector3.Distance(position, ((Component)lightLOD).transform.position);
					LightLODLevel level = ((lightLOD.Priority != LightPriority.Critical) ? ((!(num < _fullLODDistance)) ? ((num < _noShadowDistance) ? LightLODLevel.NoShadows : ((num < _emissiveDistance) ? LightLODLevel.Emissive : ((!(num < _billboardDistance)) ? LightLODLevel.Disabled : LightLODLevel.Billboard))) : LightLODLevel.Full) : LightLODLevel.Full);
					TrackedLight component = ((Component)lightLOD).GetComponent<TrackedLight>();
					bool cullingManagerActive = (Object)(object)component != (Object)null && component.IsCulled;
					lightLOD.SetLODLevel(level, cullingManagerActive);
				}
			}
		}

		private void OnDestroy()
		{
			LightLOD[] array = _allLights.ToArray();
			foreach (LightLOD lightLOD in array)
			{
				if ((Object)(object)lightLOD != (Object)null)
				{
					lightLOD.Cleanup();
				}
			}
			_allLights.Clear();
			_lightSet.Clear();
			Instance = null;
		}
	}
	public enum LightPriority
	{
		VeryLow,
		Low,
		Medium,
		High,
		Critical
	}
	public class TrackedLight : MonoBehaviour
	{
		private float _originalIntensity;

		private float _originalRange;

		private LightShadows _originalShadows;

		private bool _hadShadows;

		private bool _isCurrentlyCulled;

		public Light LightSource { get; private set; }

		public LightPriority Priority { get; private set; }

		public bool IsCulled => _isCurrentlyCulled;

		public bool IsActiveLight
		{
			get
			{
				if ((Object)(object)LightSource != (Object)null && ((Behaviour)LightSource).enabled)
				{
					return LightSource.intensity > 0.01f;
				}
				return false;
			}
		}

		public bool HasShadows => _hadShadows;

		private void Awake()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Invalid comparison between Unknown and I4
			LightSource = ((Component)this).GetComponent<Light>();
			if ((Object)(object)LightSource == (Object)null)
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			_originalIntensity = LightSource.intensity;
			_originalRange = LightSource.range;
			_originalShadows = LightSource.shadows;
			_hadShadows = (int)_originalShadows > 0;
			DeterminePriority();
		}

		private void DeterminePriority()
		{
			if ((Object)(object)LightSource == (Object)null)
			{
				Priority = LightPriority.VeryLow;
				return;
			}
			string text = (((Object)(object)((Component)this).transform.parent != (Object)null) ? ((Object)((Component)this).transform.parent).name.ToLower() : "");
			string text2 = ((Object)((Component)this).gameObject).name.ToLower();
			if ((Object)(object)((Component)((Component)this).transform.root).GetComponent<Player>() != (Object)null)
			{
				Priority = LightPriority.Critical;
			}
			else if (text.Contains("fire") || text.Contains("hearth") || text.Contains("brazier") || text2.Contains("fire"))
			{
				Priority = LightPriority.High;
			}
			else if (text.Contains("torch") || text.Contains("candle") || text2.Contains("torch") || text2.Contains("candle"))
			{
				Priority = LightPriority.Medium;
			}
			else if (LightSource.intensity > 2f)
			{
				Priority = LightPriority.High;
			}
			else if (LightSource.intensity > 1f)
			{
				Priority = LightPriority.Medium;
			}
			else
			{
				Priority = LightPriority.Low;
			}
		}

		public void SetCulled(bool cull, bool disableShadows = false)
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)LightSource == (Object)null)
			{
				return;
			}
			if (cull)
			{
				if (!_isCurrentlyCulled)
				{
					_originalIntensity = LightSource.intensity;
					_originalRange = LightSource.range;
					LightSource.intensity = 0f;
					LightSource.range = 0f;
					if (disableShadows && _hadShadows)
					{
						_originalShadows = LightSource.shadows;
						LightSource.shadows = (LightShadows)0;
					}
				}
			}
			else if (_isCurrentlyCulled)
			{
				LightSource.intensity = _originalIntensity;
				LightSource.range = _originalRange;
				if (_hadShadows)
				{
					LightSource.shadows = _originalShadows;
				}
			}
			_isCurrentlyCulled = cull;
		}

		public void SetShadowsOnly(bool enabled)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)LightSource == (Object)null) && _hadShadows)
			{
				LightSource.shadows = (LightShadows)(enabled ? ((int)_originalShadows) : 0);
			}
		}

		public void Cleanup()
		{
			if (_isCurrentlyCulled)
			{
				SetCulled(cull: false);
			}
			_isCurrentlyCulled = false;
			Object.Destroy((Object)(object)this);
		}
	}
	public class AdvancedLightManager : MonoBehaviour
	{
		private struct LightInfo
		{
			public TrackedLight Light;

			public float DistanceSqr;

			public LightPriority Priority;
		}

		private readonly List<TrackedLight> _allLights = new List<TrackedLight>(512);

		private readonly HashSet<TrackedLight> _culledLights = new HashSet<TrackedLight>();

		private const int MAX_LIGHT_INFOS = 1024;

		private const int MAX_TRACKED_LIGHTS = 512;

		private LightInfo[] _lightInfos = new LightInfo[256];

		private int _lightInfoCount;

		private float _updateTimer;

		private int _cleanupCounter;

		private const float UPDATE_INTERVAL = 0.25f;

		private int _maxActiveLights = 15;

		private int _maxShadowCasters = 5;

		private float _lightCullDistance = 60f;

		private float _shadowCullDistance = 30f;

		private static readonly IComparer<LightInfo> _lightComparer = Comparer<LightInfo>.Create(delegate(LightInfo a, LightInfo b)
		{
			int num = a.Priority.CompareTo(b.Priority);
			return (num == 0) ? a.DistanceSqr.CompareTo(b.DistanceSqr) : num;
		});

		public static AdvancedLightManager Instance { get; private set; }

		public int TotalLights => _allLights.Count;

		public int CulledLights => _culledLights.Count;

		public int ActiveLights => _allLights.Count - _culledLights.Count;

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Instance = this;
			LoadConfig();
		}

		private void LoadConfig()
		{
			_maxActiveLights = Plugin.MaxActiveLights?.Value ?? 15;
			_lightCullDistance = Plugin.LightCullDistance?.Value ?? 60f;
			_maxShadowCasters = Plugin.MaxShadowCasters?.Value ?? 5;
			_shadowCullDistance = Plugin.ShadowCullDistance?.Value ?? 30f;
		}

		private void Start()
		{
			if (!Plugin.LightCullingEnabled.Value)
			{
				((Behaviour)this).enabled = false;
				return;
			}
			Plugin.Log.LogInfo((object)"[LightCulling] Advanced manager starting...");
			PerformLightScan();
			Plugin.Log.LogInfo((object)$"[LightCulling] Found {_allLights.Count} lights at startup.");
		}

		private void PerformLightScan()
		{
			Light[] array = Object.FindObjectsByType<Light>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			foreach (Light light in array)
			{
				TryRegisterLight(light);
			}
		}

		public void TryRegisterLight(Light light)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			if ((Object)(object)light == (Object)null || (Object)(object)((Component)light).GetComponent<TrackedLight>() != (Object)null || (int)light.type == 1 || light.intensity <= 0.1f)
			{
				return;
			}
			if (_allLights.Count >= 512)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogWarning((object)$"[LightCulling] Max tracked lights reached ({512}), ignoring: {((Object)light).name}");
				}
				return;
			}
			TrackedLight trackedLight = ((Component)light).gameObject.AddComponent<TrackedLight>();
			_allLights.Add(trackedLight);
			if (_allLights.Count > _lightInfos.Length && _lightInfos.Length < 1024)
			{
				int newSize = Mathf.Min(_lightInfos.Length * 2, 1024);
				Array.Resize(ref _lightInfos, newSize);
			}
			if (Plugin.DebugLoggingEnabled.Value)
			{
				Plugin.Log.LogInfo((object)$"[LightCulling] Registered: {((Object)light).name} (Priority: {trackedLight.Priority})");
			}
		}

		private void OnDestroy()
		{
			TrackedLight[] array = _allLights.ToArray();
			foreach (TrackedLight trackedLight in array)
			{
				if ((Object)(object)trackedLight != (Object)null)
				{
					trackedLight.Cleanup();
				}
			}
			_allLights.Clear();
			_culledLights.Clear();
			Instance = null;
		}

		private void Update()
		{
			if (!Plugin.LightCullingEnabled.Value)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else
			{
				if ((Object)(object)Camera.main == (Object)null || (Object)(object)Player.m_localPlayer == (Object)null)
				{
					return;
				}
				_updateTimer += Time.deltaTime;
				if (!(_updateTimer < 0.25f))
				{
					_updateTimer = 0f;
					_cleanupCounter++;
					if (_cleanupCounter >= 10)
					{
						_cleanupCounter = 0;
						CleanupNullLights();
					}
					UpdateLightCulling();
				}
			}
		}

		private void CleanupNullLights()
		{
			int num = 0;
			for (int num2 = _allLights.Count - 1; num2 >= 0; num2--)
			{
				if ((Object)(object)_allLights[num2] == (Object)null || (Object)(object)_allLights[num2].LightSource == (Object)null)
				{
					_culledLights.Remove(_allLights[num2]);
					_allLights.RemoveAt(num2);
					num++;
				}
			}
			_culledLights.RemoveWhere((TrackedLight t) => (Object)(object)t == (Object)null || (Object)(object)t.LightSource == (Object)null);
			if (_allLights.Count < _lightInfos.Length / 4 && _lightInfos.Length > 256)
			{
				int newSize = Mathf.Max(256, _allLights.Count * 2);
				Array.Resize(ref _lightInfos, newSize);
			}
			if (Plugin.DebugLoggingEnabled.Value && num > 0)
			{
				Plugin.Log.LogInfo((object)($"[LightCulling] Cleaned {num} null lights. " + $"All={_allLights.Count} Culled={_culledLights.Count} Array={_lightInfos.Length}"));
			}
		}

		private void UpdateLightCulling()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			if (_allLights.Count == 0)
			{
				return;
			}
			Vector3 position = ((Component)Camera.main).transform.position;
			float num = _lightCullDistance * _lightCullDistance;
			float num2 = _shadowCullDistance * _shadowCullDistance;
			_lightInfoCount = 0;
			for (int i = 0; i < _allLights.Count; i++)
			{
				TrackedLight trackedLight = _allLights[i];
				if ((Object)(object)trackedLight == (Object)null || (Object)(object)trackedLight.LightSource == (Object)null)
				{
					continue;
				}
				Vector3 val = position - ((Component)trackedLight).transform.position;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude <= num)
				{
					if (_lightInfoCount < _lightInfos.Length)
					{
						_lightInfos[_lightInfoCount] = new LightInfo
						{
							Light = trackedLight,
							DistanceSqr = sqrMagnitude,
							Priority = trackedLight.Priority
						};
						_lightInfoCount++;
					}
				}
				else if (!trackedLight.IsCulled)
				{
					trackedLight.SetCulled(cull: true, disableShadows: true);
					_culledLights.Add(trackedLight);
				}
			}
			QuickSelectTopN(_lightInfos, _lightInfoCount, _maxActiveLights);
			int num3 = 0;
			int num4 = 0;
			int num5 = Math.Min(_lightInfoCount, _maxActiveLights * 2);
			for (int j = 0; j < num5; j++)
			{
				LightInfo lightInfo = _lightInfos[j];
				TrackedLight light = lightInfo.Light;
				bool flag = lightInfo.DistanceSqr <= num2 && num4 < _maxShadowCasters && light.HasShadows;
				if (num3 < _maxActiveLights)
				{
					if (light.IsCulled)
					{
						light.SetCulled(cull: false);
						_culledLights.Remove(light);
					}
					light.SetShadowsOnly(flag);
					if (flag)
					{
						num4++;
					}
					num3++;
				}
				else if (!light.IsCulled)
				{
					light.SetCulled(cull: true, disableShadows: true);
					_culledLights.Add(light);
				}
			}
			if (Plugin.DebugLoggingEnabled.Value && Time.frameCount % 60 == 0)
			{
				Plugin.Log.LogInfo((object)($"[LightCulling] Active: {num3}/{_maxActiveLights}, " + $"Shadows: {num4}/{_maxShadowCasters}, " + $"Total: {_allLights.Count}, Culled: {_culledLights.Count}"));
			}
		}

		private void QuickSelectTopN(LightInfo[] array, int length, int topN)
		{
			if (length <= topN)
			{
				return;
			}
			int num = 0;
			int num2 = length - 1;
			topN = Math.Min(topN, length);
			while (num < num2)
			{
				int num3 = Partition(array, num, num2);
				if (num3 == topN)
				{
					break;
				}
				if (num3 < topN)
				{
					num = num3 + 1;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			Array.Sort(array, 0, Math.Min(topN, length), _lightComparer);
		}

		private int Partition(LightInfo[] array, int left, int right)
		{
			LightInfo lightInfo = array[right];
			int num = left - 1;
			for (int i = left; i < right; i++)
			{
				int num2 = array[i].Priority.CompareTo(lightInfo.Priority);
				if (num2 < 0 || (num2 == 0 && array[i].DistanceSqr < lightInfo.DistanceSqr))
				{
					num++;
					LightInfo lightInfo2 = array[num];
					array[num] = array[i];
					array[i] = lightInfo2;
				}
			}
			LightInfo lightInfo3 = array[num + 1];
			array[num + 1] = array[right];
			array[right] = lightInfo3;
			return num + 1;
		}

		public void ForceUpdate()
		{
			_updateTimer = 0.25f;
		}
	}
}
namespace ValheimPerformanceOverhaul.Pieces
{
	public class DecorBatcher : MonoBehaviour
	{
		private class BatchChunk
		{
			private struct PieceEntry
			{
				public Piece Piece;

				public MeshFilter MF;

				public MeshRenderer MR;
			}

			public Vector2Int GridPos;

			public bool IsDirty;

			public float LastUpdateTime;

			private readonly List<PieceEntry> _entries = new List<PieceEntry>();

			private GameObject _batchRoot;

			private Mesh _combinedMesh;

			public BatchChunk(Vector2Int pos)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				GridPos = pos;
			}

			public void AddPiece(Piece p, MeshFilter mf, MeshRenderer mr)
			{
				_entries.Add(new PieceEntry
				{
					Piece = p,
					MF = mf,
					MR = mr
				});
				MarkDirty();
			}

			public void RemovePiece(Piece p)
			{
				int num = _entries.FindIndex((PieceEntry e) => (Object)(object)e.Piece == (Object)(object)p);
				if (num != -1)
				{
					if ((Object)(object)_entries[num].MR != (Object)null)
					{
						((Renderer)_entries[num].MR).enabled = true;
					}
					_entries.RemoveAt(num);
					MarkDirty();
				}
			}

			private void MarkDirty()
			{
				IsDirty = true;
				LastUpdateTime = Time.time;
			}

			public void RestoreAllRenderers()
			{
				foreach (PieceEntry entry in _entries)
				{
					if ((Object)(object)entry.MR != (Object)null)
					{
						((Renderer)entry.MR).enabled = true;
					}
				}
				DestroyBatchRoot();
			}

			public void Rebuild(int minPieces)
			{
				//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c3: Expected O, but got Unknown
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0200: Unknown result type (might be due to invalid IL or missing references)
				//IL_0205: Unknown result type (might be due to invalid IL or missing references)
				//IL_021b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0221: Unknown result type (might be due to invalid IL or missing references)
				//IL_022b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0239: Unknown result type (might be due to invalid IL or missing references)
				//IL_0243: Expected O, but got Unknown
				//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
				IsDirty = false;
				foreach (PieceEntry entry in _entries)
				{
					if ((Object)(object)entry.MR != (Object)null)
					{
						((Renderer)entry.MR).enabled = true;
					}
				}
				DestroyBatchRoot();
				for (int num = _entries.Count - 1; num >= 0; num--)
				{
					if ((Object)(object)_entries[num].Piece == (Object)null || (Object)(object)_entries[num].MF == (Object)null || (Object)(object)_entries[num].MR == (Object)null)
					{
						_entries.RemoveAt(num);
					}
				}
				if (_entries.Count < minPieces)
				{
					return;
				}
				Dictionary<Material, List<CombineInstance>> dictionary = new Dictionary<Material, List<CombineInstance>>();
				foreach (PieceEntry entry2 in _entries)
				{
					Material sharedMaterial = ((Renderer)entry2.MR).sharedMaterial;
					if (!((Object)(object)sharedMaterial == (Object)null))
					{
						if (!dictionary.ContainsKey(sharedMaterial))
						{
							dictionary[sharedMaterial] = new List<CombineInstance>();
						}
						List<CombineInstance> list = dictionary[sharedMaterial];
						CombineInstance item = default(CombineInstance);
						((CombineInstance)(ref item)).mesh = entry2.MF.sharedMesh;
						((CombineInstance)(ref item)).transform = ((Component)entry2.MF).transform.localToWorldMatrix;
						list.Add(item);
						((Renderer)entry2.MR).enabled = false;
					}
				}
				_batchRoot = new GameObject($"_Batch_{((Vector2Int)(ref GridPos)).x}_{((Vector2Int)(ref GridPos)).y}");
				foreach (KeyValuePair<Material, List<CombineInstance>> item2 in dictionary)
				{
					if (item2.Value.Count != 0)
					{
						GameObject val = new GameObject("Batch_" + ((Object)item2.Key).name);
						val.transform.SetParent(_batchRoot.transform);
						val.transform.position = Vector3.zero;
						MeshFilter val2 = val.AddComponent<MeshFilter>();
						MeshRenderer obj = val.AddComponent<MeshRenderer>();
						_combinedMesh = new Mesh();
						_combinedMesh.CombineMeshes(item2.Value.ToArray(), true, true);
						val2.sharedMesh = _combinedMesh;
						((Renderer)obj).sharedMaterial = item2.Key;
					}
				}
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)$"[DecorBatcher] Rebuilt chunk {GridPos} with {_entries.Count} pieces.");
				}
			}

			private void DestroyBatchRoot()
			{
				if ((Object)(object)_combinedMesh != (Object)null)
				{
					Object.Destroy((Object)(object)_combinedMesh);
					_combinedMesh = null;
				}
				if ((Object)(object)_batchRoot != (Object)null)
				{
					Object.Destroy((Object)(object)_batchRoot);
					_batchRoot = null;
				}
			}
		}

		private static ConfigEntry<bool> _batchingEnabledEntry;

		private static ConfigEntry<int> _minPiecesToBatch;

		private static ConfigEntry<float> _rebuildCooldown;

		private const int GRID_SIZE = 32;

		private readonly Dictionary<Vector2Int, BatchChunk> _chunks = new Dictionary<Vector2Int, BatchChunk>();

		public static DecorBatcher Instance { get; private set; }

		private static bool BatchingEnabled
		{
			get
			{
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Expected O, but got Unknown
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Expected O, but got Unknown
				if (_batchingEnabledEntry == null && (Object)(object)Plugin.Instance != (Object)null)
				{
					_batchingEnabledEntry = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<bool>("17. Decor Batching", "Enabled", false, "Combines meshes of decorative (Misc category) pieces in a chunk grid to reduce draw calls. Only affects pieces without WearNTear. Enable on potato PCs with many decorations; leave OFF if unsure.");
					_minPiecesToBatch = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<int>("17. Decor Batching", "Min Pieces To Batch", 3, new ConfigDescription("Minimum number of pieces in a chunk before batching is applied.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(2, 20), Array.Empty<object>()));
					_rebuildCooldown = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>("17. Decor Batching", "Rebuild Cooldown (seconds)", 2f, new ConfigDescription("How long to wait after a piece change before rebuilding the combined mesh.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 10f), Array.Empty<object>()));
				}
				return _batchingEnabledEntry?.Value ?? false;
			}
		}

		private void Awake()
		{
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			Plugin.Log.LogInfo((object)"[DecorBatcher] Initialized.");
		}

		public void RegisterPiece(Piece piece)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if (!BatchingEnabled || (int)piece.m_category != 0 || (Object)(object)((Component)piece).GetComponent<WearNTear>() != (Object)null || (Object)(object)((Component)piece).GetComponent<ZSyncTransform>() != (Object)null || (Object)(object)((Component)piece).GetComponent<Rigidbody>() != (Object)null)
			{
				return;
			}
			MeshFilter componentInChildren = ((Component)piece).GetComponentInChildren<MeshFilter>();
			MeshRenderer componentInChildren2 = ((Component)piece).GetComponentInChildren<MeshRenderer>();
			if (!((Object)(object)componentInChildren == (Object)null) && !((Object)(object)componentInChildren2 == (Object)null) && !((Object)(object)((Renderer)componentInChildren2).sharedMaterial == (Object)null))
			{
				Vector2Int gridPos = GetGridPos(((Component)piece).transform.position);
				if (!_chunks.ContainsKey(gridPos))
				{
					_chunks[gridPos] = new BatchChunk(gridPos);
				}
				_chunks[gridPos].AddPiece(piece, componentInChildren, componentInChildren2);
			}
		}

		public void UnregisterPiece(Piece piece)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (BatchingEnabled)
			{
				Vector2Int gridPos = GetGridPos(((Component)piece).transform.position);
				if (_chunks.TryGetValue(gridPos, out var value))
				{
					value.RemovePiece(piece);
				}
			}
		}

		private Vector2Int GetGridPos(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2Int(Mathf.FloorToInt(pos.x / 32f), Mathf.FloorToInt(pos.z / 32f));
		}

		private void Update()
		{
			if (!BatchingEnabled)
			{
				return;
			}
			float num = _rebuildCooldown?.Value ?? 2f;
			foreach (BatchChunk value in _chunks.Values)
			{
				if (value.IsDirty && Time.time - value.LastUpdateTime > num)
				{
					value.Rebuild(_minPiecesToBatch?.Value ?? 3);
					break;
				}
			}
		}

		private void OnDestroy()
		{
			foreach (BatchChunk value in _chunks.Values)
			{
				value.RestoreAllRenderers();
			}
			_chunks.Clear();
			Instance = null;
		}
	}
	[HarmonyPatch(typeof(Piece), "Awake")]
	public static class DecorBatcher_Awake_Patch
	{
		[HarmonyPostfix]
		private static void Postfix(Piece __instance)
		{
			if (((Component)__instance).gameObject.layer != LayerMask.NameToLayer("ghost"))
			{
				DecorBatcher.Instance?.RegisterPiece(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Piece), "OnDestroy")]
	public static class DecorBatcher_OnDestroy_Patch
	{
		[HarmonyPostfix]
		private static void Postfix(Piece __instance)
		{
			DecorBatcher.Instance?.UnregisterPiece(__instance);
		}
	}
	[HarmonyPatch(typeof(Piece), "Awake")]
	public static class DecorOptimizer
	{
		[HarmonyPostfix]
		private static void Postfix(Piece __instance)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.PieceOptimizationEnabled.Value && ((Component)__instance).gameObject.layer != LayerMask.NameToLayer("ghost") && (int)__instance.m_category == 0)
			{
				OptimizeDecor(__instance);
			}
		}

		private static void OptimizeDecor(Piece piece)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)piece == (Object)null || (Object)(object)((Component)piece).GetComponent<ZSyncTransform>() != (Object)null || (Object)(object)((Component)piece).GetComponent<Character>() != (Object)null || (Object)(object)((Component)piece).GetComponent<BaseAI>() != (Object)null)
			{
				return;
			}
			string value = ((Object)piece).name.Replace("(Clone)", "");
			if (Plugin.CullerExclusions.Value.Contains(value))
			{
				return;
			}
			GameObject gameObject = ((Component)piece).gameObject;
			if ((Object)(object)gameObject == (Object)null || (Object)(object)gameObject.GetComponentInChildren<Rigidbody>(true) == (Object)null)
			{
				return;
			}
			try
			{
				Rigidbody[] componentsInChildren = gameObject.GetComponentsInChildren<Rigidbody>(true);
				foreach (Rigidbody val in componentsInChildren)
				{
					if (!((Object)(object)val == (Object)null))
					{
						if (!val.isKinematic)
						{
							val.velocity = Vector3.zero;
							val.angularVelocity = Vector3.zero;
							val.Sleep();
						}
						val.isKinematic = true;
						if (Plugin.DebugLoggingEnabled.Value)
						{
							Plugin.Log.LogInfo((object)("[DecorOptimizer] Force Kinematic on " + ((Object)piece).name + " / " + ((Object)((Component)val).gameObject).name));
						}
					}
				}
			}
			catch (Exception ex)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogError((object)("[DecorOptimizer] Error on " + ((Object)gameObject).name + ": " + ex.Message));
				}
			}
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "CreateObject")]
	public static class DistanceCuller_CreateObject_Patch
	{
		[HarmonyPostfix]
		private static void Postfix(ZDO zdo, GameObject __result)
		{
			if (!Plugin.DistanceCullerEnabled.Value || (Object)(object)__result == (Object)null)
			{
				return;
			}
			ZNetView component = __result.GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return;
			}
			string text = ((Object)__result).name.Replace("(Clone)", "").Trim();
			if (IsExcluded(text))
			{
				DistanceCuller component2 = __result.GetComponent<DistanceCuller>();
				if ((Object)(object)component2 != (Object)null)
				{
					Object.Destroy((Object)(object)component2);
					if (Plugin.DebugLoggingEnabled.Value)
					{
						Plugin.Log.LogInfo((object)("[DistanceCuller] Removed from excluded: " + text));
					}
				}
				return;
			}
			if ((Object)(object)__result.GetComponent<DistanceCuller>() != (Object)null)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogWarning((object)("[DistanceCuller] Already attached to " + text));
				}
				return;
			}
			bool flag = (Object)(object)__result.GetComponent<Character>() != (Object)null;
			bool flag2 = (Object)(object)__result.GetComponent<Piece>() != (Object)null;
			if (!flag && !flag2)
			{
				return;
			}
			if (HasNetworkManagedRigidbody(__result))
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)("[DistanceCuller] Skipped (ZSyncTransform+Rigidbody): " + text));
				}
				return;
			}
			DistanceCuller distanceCuller = __result.AddComponent<DistanceCuller>();
			distanceCuller.CullDistance = (flag ? Plugin.CreatureCullDistance.Value : Plugin.PieceCullDistance.Value);
			if (Plugin.DebugLoggingEnabled.Value)
			{
				Plugin.Log.LogInfo((object)("[DistanceCuller] Attached to " + text + " " + string.Format("({0}, {1}m)", flag ? "Creature" : "Piece", distanceCuller.CullDistance)));
			}
		}

		private static bool HasNetworkManagedRigidbody(GameObject root)
		{
			Rigidbody[] componentsInChildren = root.GetComponentsInChildren<Rigidbody>(true);
			if (componentsInChildren == null || componentsInChildren.Length == 0)
			{
				return false;
			}
			Rigidbody[] array = componentsInChildren;
			foreach (Rigidbody val in array)
			{
				if (!((Object)(object)val == (Object)null) && (Object)(object)((Component)val).GetComponentInParent<ZSyncTransform>(true) != (Object)null)
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsExcluded(string name)
		{
			string value = Plugin.CullerExclusions.Value;
			if (string.IsNullOrEmpty(value))
			{
				return false;
			}
			string[] array = value.Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].Trim().Equals(name, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}
	}
	[HarmonyPatch]
	public static class RainDamagePatch
	{
		public static ConfigEntry<bool> DisableRainDamage;

		[HarmonyPatch(typeof(WearNTear), "HaveRoof")]
		[HarmonyPostfix]
		private static void HaveRoof_Postfix(ref bool __result)
		{
			if (Plugin.PieceOptimizationEnabled.Value && DisableRainDamage.Value)
			{
				__result = true;
			}
		}

		[HarmonyPatch(typeof(WearNTear), "IsUnderWater")]
		[HarmonyPostfix]
		private static void IsUnderWater_Postfix(ref bool __result)
		{
			if (Plugin.PieceOptimizationEnabled.Value && DisableRainDamage.Value)
			{
				__result = false;
			}
		}
	}
	public class AsyncWearManager : MonoBehaviour
	{
		private readonly Queue<WearNTear> _pending = new Queue<WearNTear>();

		private const int MAX_PER_FRAME = 20;

		public static AsyncWearManager Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		public void Enqueue(WearNTear wnt)
		{
			if ((Object)(object)wnt != (Object)null)
			{
				_pending.Enqueue(wnt);
			}
		}

		private void Update()
		{
			if (_pending.Count == 0)
			{
				return;
			}
			int num = 0;
			while (_pending.Count > 0 && num < 20)
			{
				WearNTear val = _pending.Dequeue();
				if ((Object)(object)val != (Object)null)
				{
					((Behaviour)val).enabled = true;
				}
				num++;
			}
		}

		private void OnDestroy()
		{
			_pending.Clear();
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}
	}
	[HarmonyPatch(typeof(WearNTear), "Awake")]
	public static class WearNTear_Awake_Patch
	{
		[HarmonyPostfix]
		private static void Postfix(WearNTear __instance)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.PieceOptimizationEnabled.Value)
			{
				if ((Object)(object)AsyncWearManager.Instance == (Object)null)
				{
					new GameObject("_VPO_AsyncWearManager").AddComponent<AsyncWearManager>();
				}
				if (((Behaviour)__instance).enabled)
				{
					((Behaviour)__instance).enabled = false;
					AsyncWearManager.Instance.Enqueue(__instance);
				}
			}
		}
	}
	public class PieceSleepManager : MonoBehaviour
	{
		public class PieceContext
		{
			public Piece Piece;

			public WearNTear WearNTear;

			public bool IsSleeping;

			public bool IsDirty = true;

			public int ActiveFrames;
		}

		private static readonly ConditionalWeakTable<Piece, PieceContext> _pieceContexts = new ConditionalWeakTable<Piece, PieceContext>();

		private static readonly HashSet<PieceContext> _activePieces = new HashSet<PieceContext>();

		private static readonly List<PieceContext> _toSleepBuffer = new List<PieceContext>(128);

		public static PieceSleepManager Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		public static void RegisterPiece(Piece piece)
		{
			if (!((Object)(object)piece == (Object)null))
			{
				WearNTear component = ((Component)piece).GetComponent<WearNTear>();
				if (!((Object)(object)component == (Object)null))
				{
					PieceContext pieceContext = new PieceContext
					{
						Piece = piece,
						WearNTear = component,
						IsSleeping = false
					};
					_pieceContexts.Add(piece, pieceContext);
					_activePieces.Add(pieceContext);
				}
			}
		}

		public static void WakeUp(Piece piece)
		{
			if (!((Object)(object)piece == (Object)null) && _pieceContexts.TryGetValue(piece, out var value))
			{
				value.IsDirty = true;
				value.ActiveFrames = 0;
				value.IsSleeping = false;
				if ((Object)(object)value.WearNTear != (Object)null)
				{
					((Behaviour)value.WearNTear).enabled = true;
				}
				_activePieces.Add(value);
			}
		}

		private void Update()
		{
			_toSleepBuffer.Clear();
			foreach (PieceContext activePiece in _activePieces)
			{
				if ((Object)(object)activePiece.Piece == (Object)null || (Object)(object)activePiece.WearNTear == (Object)null)
				{
					_toSleepBuffer.Add(activePiece);
				}
				else if (activePiece.IsDirty)
				{
					activePiece.ActiveFrames++;
					if (activePiece.ActiveFrames >= 2)
					{
						activePiece.IsDirty = false;
						activePiece.IsSleeping = true;
						((Behaviour)activePiece.WearNTear).enabled = false;
						_toSleepBuffer.Add(activePiece);
					}
				}
			}
			foreach (PieceContext item in _toSleepBuffer)
			{
				_activePieces.Remove(item);
			}
		}

		private void OnDestroy()
		{
			Instance = null;
		}
	}
	[HarmonyPatch]
	public static class SupportCache
	{
		private struct InvalidationTask
		{
			public Vector3 pos;

			public Vector3 size;

			public Quaternion rot;
		}

		private class CachedSupport
		{
			public float Value;

			public float Timestamp;
		}

		private static readonly ConditionalWeakTable<WearNTear, CachedSupport> _supportCache;

		private static readonly Collider[] _neighborBuffer;

		private static readonly int _rayMask;

		private static readonly MethodInfo _clearSupportMethod;

		private static readonly FieldInfo _boundsField;

		private static readonly FieldInfo _posField;

		private static readonly FieldInfo _sizeField;

		private static readonly FieldInfo _rotField;

		private static readonly Queue<InvalidationTask> _invalidationQueue;

		private static float CacheDuration => Plugin.PieceSupportCacheDuration.Value;

		static SupportCache()
		{
			_supportCache = new ConditionalWeakTable<WearNTear, CachedSupport>();
			_neighborBuffer = (Collider[])(object)new Collider[64];
			_rayMask = LayerMask.GetMask(new string[2] { "piece", "piece_nonsolid" });
			_clearSupportMethod = AccessTools.Method(typeof(WearNTear), "ClearCachedSupport", (Type[])null, (Type[])null);
			_invalidationQueue = new Queue<InvalidationTask>();
			_boundsField = AccessTools.Field(typeof(WearNTear), "m_bounds");
			Type type = AccessTools.Inner(typeof(WearNTear), "BoundData");
			if (type != null)
			{
				_posField = AccessTools.Field(type, "m_pos");
				_sizeField = AccessTools.Field(type, "m_size");
				_rotField = AccessTools.Field(type, "m_rot");
			}
		}

		[HarmonyPatch(typeof(WearNTear), "GetSupport")]
		[HarmonyPrefix]
		private static bool GetSupport_Prefix(WearNTear __instance, ref float __result)
		{
			if (!Plugin.PieceOptimizationEnabled.Value)
			{
				return true;
			}
			if (_supportCache.TryGetValue(__instance, out var value) && Time.time - value.Timestamp < CacheDuration)
			{
				__result = value.Value;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(WearNTear), "GetSupport")]
		[HarmonyPostfix]
		private static void GetSupport_Postfix(WearNTear __instance, float __result)
		{
			if (Plugin.PieceOptimizationEnabled.Value)
			{
				CachedSupport orCreateValue = _supportCache.GetOrCreateValue(__instance);
				orCreateValue.Value = __result;
				orCreateValue.Timestamp = Time.time;
			}
		}

		[HarmonyPatch(typeof(WearNTear), "RPC_Damage")]
		[HarmonyPostfix]
		private static void RPC_Damage_Postfix(WearNTear __instance)
		{
			if (Plugin.PieceOptimizationEnabled.Value && Plugin.PieceSupportSmartInvalidation.Value)
			{
				InvalidateCache(__instance);
			}
		}

		[HarmonyPatch(typeof(WearNTear), "Destroy")]
		[HarmonyPrefix]
		private static void Destroy_Prefix(WearNTear __instance)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.PieceOptimizationEnabled.Value || !Plugin.PieceSupportSmartInvalidation.Value)
			{
				return;
			}
			try
			{
				if (!(_boundsField?.GetValue(__instance) is IEnumerable enumerable) || !(_posField != null))
				{
					return;
				}
				foreach (object item in enumerable)
				{
					_invalidationQueue.Enqueue(new InvalidationTask
					{
						pos = (Vector3)_posField.GetValue(item),
						size = (Vector3)_sizeField.GetValue(item),
						rot = (Quaternion)_rotField.GetValue(item)
					});
				}
			}
			catch (Exception ex)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogWarning((object)("[SupportCache] Error queueing bounds: " + ex.Message));
				}
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Update")]
		[HarmonyPostfix]
		private static void ProcessInvalidationQueue()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (_invalidationQueue.Count == 0)
			{
				return;
			}
			int num = 0;
			while (_invalidationQueue.Count > 0 && num < 5)
			{
				InvalidationTask invalidationTask = _invalidationQueue.Dequeue();
				int num2 = Physics.OverlapBoxNonAlloc(invalidationTask.pos, invalidationTask.size, _neighborBuffer, invalidationTask.rot, _rayMask);
				for (int i = 0; i < num2; i++)
				{
					Collider val = _neighborBuffer[i];
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.attachedRigidbody != (Object)null) && !val.isTrigger)
					{
						WearNTear componentInParent = ((Component)val).GetComponentInParent<WearNTear>();
						if ((Object)(object)componentInParent != (Object)null)
						{
							InvalidateCache(componentInParent);
						}
					}
				}
				Array.Clear(_neighborBuffer, 0, num2);
				num++;
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "OnDestroy")]
		[HarmonyPostfix]
		private static void ZNetScene_OnDestroy_Postfix()
		{
			_invalidationQueue.Clear();
			ConfigEntry<bool> debugLoggingEnabled = Plugin.DebugLoggingEnabled;
			if (debugLoggingEnabled != null && debugLoggingEnabled.Value)
			{
				Plugin.Log.LogInfo((object)"[SupportCache] Invalidation queue cleared on scene unload.");
			}
		}

		private static void InvalidateCache(WearNTear wnt)
		{
			if (!((Object)(object)wnt == (Object)null))
			{
				_supportCache.Remove(wnt);
				ZNetView component = ((Component)wnt).GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.IsValid() && component.IsOwner())
				{
					_clearSupportMethod?.Invoke(wnt, null);
				}
			}
		}
	}
}
namespace ValheimPerformanceOverhaul.Optimizations
{
	public class LODGenerationRequest
	{
		public GameObject Prefab;

		public string PrefabName;

		public List<RendererMeshData> OriginalRenderers;

		public Task<DecimationResult> DecimationTask;
	}
	public class RendererMeshData
	{
		public Renderer Renderer;

		public string RelativePath;

		public SerializableMesh OriginalMesh;
	}
	public class DecimationResult
	{
		public List<DecimatedRendererData> DecimatedData;
	}
	public class DecimatedRendererData
	{
		public RendererMeshData OriginalData;

		public SerializableMesh LOD1Mesh;

		public SerializableMesh LOD2Mesh;
	}
	public class LODGeneratorManager : MonoBehaviour
	{
		private readonly Queue<LODGenerationRequest> _pendingRequests = new Queue<LODGenerationRequest>();

		private LODGenerationRequest _activeRequest;

		private float _timeSinceLastProcess;

		private const float PROCESS_INTERVAL = 0.05f;

		public static LODGeneratorManager Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		public void Enqueue(LODGenerationRequest request)
		{
			_pendingRequests.Enqueue(request);
		}

		private void Update()
		{
			if (_activeRequest != null)
			{
				if (_activeRequest.DecimationTask == null || !_activeRequest.DecimationTask.IsCompleted)
				{
					return;
				}
				try
				{
					DecimationResult result = _activeRequest.DecimationTask.Result;
					if (result != null && result.DecimatedData.Count > 0)
					{
						ApplyLODGroup(_activeRequest, result);
						AssetCache.SaveLODsToCache(_activeRequest.PrefabName, "2.7.0", GetGameVersion(), result);
						if (Plugin.DebugLoggingEnabled.Value)
						{
							Plugin.Log.LogInfo((object)("[LODGenerator] Generated and cached LODs for " + _activeRequest.PrefabName));
						}
					}
					return;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogError((object)("[LODGenerator] Asynchronous decimation failed for " + _activeRequest.PrefabName + ": " + ex.Message));
					return;
				}
				finally
				{
					_activeRequest = null;
				}
			}
			_timeSinceLastProcess += Time.deltaTime;
			if (_timeSinceLastProcess < 0.05f)
			{
				return;
			}
			_timeSinceLastProcess = 0f;
			if (_pendingRequests.Count == 0)
			{
				return;
			}
			LODGenerationRequest next = _pendingRequests.Dequeue();
			if ((Object)(object)next.Prefab == (Object)null)
			{
				return;
			}
			DecimationResult decimationResult = AssetCache.LoadLODsFromCache(next.PrefabName, "2.7.0", GetGameVersion(), next.OriginalRenderers);
			if (decimationResult != null)
			{
				ApplyLODGroup(next, decimationResult);
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)("[LODGenerator] Applied cached LODs for " + next.PrefabName));
				}
				return;
			}
			_activeRequest = next;
			float q1 = Plugin.LOD1Quality?.Value ?? 0.5f;
			float q2 = Plugin.LOD2Quality?.Value ?? 0.15f;
			_activeRequest.DecimationTask = Task.Run(() => LODGenerator.PerformDecimationInBackground(next.OriginalRenderers, q1, q2));
		}

		private void ApplyLODGroup(LODGenerationRequest request, DecimationResult result)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)request.Prefab == (Object)null)
			{
				return;
			}
			LODGroup componentInChildren = request.Prefab.GetComponentInChildren<LODGroup>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				return;
			}
			componentInChildren = request.Prefab.AddComponent<LODGroup>();
			List<Renderer> list = new List<Renderer>();
			List<Renderer> list2 = new List<Renderer>();
			List<Renderer> list3 = new List<Renderer>();
			foreach (DecimatedRendererData decimatedDatum in result.DecimatedData)
			{
				Renderer renderer = decimatedDatum.OriginalData.Renderer;
				if ((Object)(object)renderer == (Object)null)
				{
					continue;
				}
				list.Add(renderer);
				Mesh sharedMesh = decimatedDatum.LOD1Mesh.ToMesh();
				Mesh sharedMesh2 = decimatedDatum.LOD2Mesh.ToMesh();
				Transform parent = ((Component)renderer).transform.parent;
				GameObject val = new GameObject(((Object)renderer).name + "_LOD1");
				val.transform.SetParent(((Object)(object)parent != (Object)null) ? parent : ((Component)renderer).transform, false);
				GameObject val2 = new GameObject(((Object)renderer).name + "_LOD2");
				val2.transform.SetParent(((Object)(object)parent != (Object)null) ? parent : ((Component)renderer).transform, false);
				if ((Object)(object)parent != (Object)null)
				{
					val.transform.localPosition = ((Component)renderer).transform.localPosition;
					val.transform.localRotation = ((Component)renderer).transform.localRotation;
					val.transform.localScale = ((Component)renderer).transform.localScale;
					val2.transform.localPosition = ((Component)renderer).transform.localPosition;
					val2.transform.localRotation = ((Component)renderer).transform.localRotation;
					val2.transform.localScale = ((Component)renderer).transform.localScale;
				}
				else
				{
					val.transform.localPosition = Vector3.zero;
					val.transform.localRotation = Quaternion.identity;
					val.transform.localScale = Vector3.one;
					val2.transform.localPosition = Vector3.zero;
					val2.transform.localRotation = Quaternion.identity;
					val2.transform.localScale = Vector3.one;
				}
				MeshRenderer val3 = (MeshRenderer)(object)((renderer is MeshRenderer) ? renderer : null);
				if (val3 != null)
				{
					if ((Object)(object)((Component)renderer).GetComponent<MeshFilter>() != (Object)null)
					{
						val.AddComponent<MeshFilter>().sharedMesh = sharedMesh;
						MeshRenderer val4 = val.AddComponent<MeshRenderer>();
						((Renderer)val4).sharedMaterials = ((Renderer)val3).sharedMaterials;
						val2.AddComponent<MeshFilter>().sharedMesh = sharedMesh2;
						MeshRenderer val5 = val2.AddComponent<MeshRenderer>();
						((Renderer)val5).sharedMaterials = ((Renderer)val3).sharedMaterials;
						list2.Add((Renderer)(object)val4);
						list3.Add((Renderer)(object)val5);
					}
				}
				else
				{
					SkinnedMeshRenderer val6 = (SkinnedMeshRenderer)(object)((renderer is SkinnedMeshRenderer) ? renderer : null);
					if (val6 != null)
					{
						SkinnedMeshRenderer val7 = val.AddComponent<SkinnedMeshRenderer>();
						val7.sharedMesh = sharedMesh;
						((Renderer)val7).sharedMaterials = ((Renderer)val6).sharedMaterials;
						val7.bones = val6.bones;
						val7.rootBone = val6.rootBone;
						SkinnedMeshRenderer val8 = val2.AddComponent<SkinnedMeshRenderer>();
						val8.sharedMesh = sharedMesh2;
						((Renderer)val8).sharedMaterials = ((Renderer)val6).sharedMaterials;
						val8.bones = val6.bones;
						val8.rootBone = val6.rootBone;
						list2.Add((Renderer)(object)val7);
						list3.Add((Renderer)(object)val8);
					}
				}
				val.SetActive(false);
				val2.SetActive(false);
			}
			if (list.Count > 0)
			{
				componentInChildren.SetLODs((LOD[])(object)new LOD[3]
				{
					new LOD(0.4f, list.ToArray()),
					new LOD(0.15f, list2.ToArray()),
					new LOD(0.03f, list3.ToArray())
				});
				componentInChildren.RecalculateBounds();
			}
		}

		private string GetGameVersion()
		{
			try
			{
				return Application.version;
			}
			catch
			{
				return "unknown";
			}
		}

		private void OnDestroy()
		{
			_pendingRequests.Clear();
			_activeRequest = null;
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}
	}
	public static class LODGenerator
	{
		public static void SetupManager()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if ((Object)(object)LODGeneratorManager.Instance == (Object)null)
			{
				GameObject val = new GameObject("_VPO_LODGeneratorManager");
				val.AddComponent<LODGeneratorManager>();
				Object.DontDestroyOnLoad((Object)val);
			}
		}

		public static void Initialize(IEnumerable<GameObject> prefabs)
		{
			if (prefabs == null)
			{
				return;
			}
			SetupManager();
			int num = 0;
			foreach (GameObject prefab in prefabs)
			{
				if (!((Object)(object)prefab == (Object)null) && ShouldGenerateLOD(prefab))
				{
					List<RendererMeshData> list = CollectRendererData(prefab);
					if (list.Count != 0)
					{
						LODGenerationRequest request = new LODGenerationRequest
						{
							Prefab = prefab,
							PrefabName = ((Object)prefab).name,
							OriginalRenderers = list
						};
						LODGeneratorManager.Instance.Enqueue(request);
						num++;
					}
				}
			}
			if (Plugin.DebugLoggingEnabled.Value && num > 0)
			{
				Plugin.Log.LogInfo((object)$"[LODGenerator] Enqueued {num} prefabs for LOD processing.");
			}
		}

		public static DecimationResult PerformDecimationInBackground(List<RendererMeshData> originalData, float q1, float q2)
		{
			DecimationResult decimationResult = new DecimationResult();
			decimationResult.DecimatedData = new List<DecimatedRendererData>();
			foreach (RendererMeshData originalDatum in originalData)
			{
				SerializableMesh lOD1Mesh = MeshSimplifier.Simplify(originalDatum.OriginalMesh, q1);
				SerializableMesh lOD2Mesh = MeshSimplifier.Simplify(originalDatum.OriginalMesh, q2);
				decimationResult.DecimatedData.Add(new DecimatedRendererData
				{
					OriginalData = originalDatum,
					LOD1Mesh = lOD1Mesh,
					LOD2Mesh = lOD2Mesh
				});
			}
			return decimationResult;
		}

		private static bool ShouldGenerateLOD(GameObject prefab)
		{
			if (OptimizationTierResolver.Resolve(prefab) == OptimizationTier.Excluded)
			{
				return false;
			}
			if ((Object)(object)prefab.GetComponent<Character>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)prefab.GetComponentInChildren<LODGroup>(true) != (Object)null)
			{
				return false;
			}
			Renderer[] componentsInChildren = prefab.GetComponentsInChildren<Renderer>(true);
			if (componentsInChildren == null || componentsInChildren.Length == 0)
			{
				return false;
			}
			int num = Plugin.LODMinVertexCount?.Value ?? 300;
			bool result = false;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null || val is ParticleSystemRenderer)
				{
					continue;
				}
				Mesh val2 = null;
				if (val is MeshRenderer)
				{
					MeshFilter component = ((Component)val).GetComponent<MeshFilter>();
					if ((Object)(object)component != (Object)null)
					{
						val2 = component.sharedMesh;
					}
				}
				else
				{
					SkinnedMeshRenderer val3 = (SkinnedMeshRenderer)(object)((val is SkinnedMeshRenderer) ? val : null);
					if (val3 != null)
					{
						val2 = val3.sharedMesh;
					}
				}
				if ((Object)(object)val2 != (Object)null && val2.isReadable && val2.vertexCount >= num)
				{
					result = true;
					break;
				}
			}
			return result;
		}

		private static List<RendererMeshData> CollectRendererData(GameObject prefab)
		{
			List<RendererMeshData> list = new List<RendererMeshData>();
			Renderer[] componentsInChildren = prefab.GetComponentsInChildren<Renderer>(true);
			int num = Plugin.LODMinVertexCount?.Value ?? 300;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null || val is ParticleSystemRenderer)
				{
					continue;
				}
				Mesh val2 = null;
				if (val is MeshRenderer)
				{
					MeshFilter component = ((Component)val).GetComponent<MeshFilter>();
					if ((Object)(object)component != (Object)null)
					{
						val2 = component.sharedMesh;
					}
				}
				else
				{
					SkinnedMeshRenderer val3 = (SkinnedMeshRenderer)(object)((val is SkinnedMeshRenderer) ? val : null);
					if (val3 != null)
					{
						val2 = val3.sharedMesh;
					}
				}
				if ((Object)(object)val2 != (Object)null && val2.isReadable && val2.vertexCount >= num)
				{
					string relativePath = GetRelativePath(prefab.transform, ((Component)val).transform);
					list.Add(new RendererMeshData
					{
						Renderer = val,
						RelativePath = relativePath,
						OriginalMesh = new SerializableMesh(val2)
					});
				}
			}
			return list;
		}

		private static string GetRelativePath(Transform root, Transform child)
		{
			if ((Object)(object)root == (Object)(object)child)
			{
				return "";
			}
			string text = ((Object)child).name;
			Transform parent = child.parent;
			while ((Object)(object)parent != (Object)null && (Object)(object)parent != (Object)(object)root)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	public static class LODGeneratorPatch
	{
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		public static void Postfix(ZNetScene __instance)
		{
			if (Plugin.LODGenerationEnabled != null && Plugin.LODGenerationEnabled.Value)
			{
				LODGenerator.Initialize(__instance.m_prefabs);
			}
		}
	}
	public static class MeshSimplifier
	{
		private struct GridKey : IEquatable<GridKey>
		{
			public readonly int X;

			public readonly int Y;

			public readonly int Z;

			public GridKey(int x, int y, int z)
			{
				X = x;
				Y = y;
				Z = z;
			}

			public bool Equals(GridKey other)
			{
				if (X == other.X && Y == other.Y)
				{
					return Z == other.Z;
				}
				return false;
			}

			public override bool Equals(object obj)
			{
				if (obj is GridKey other)
				{
					return Equals(other);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return ((17 * 31 + X) * 31 + Y) * 31 + Z;
			}
		}

		private struct SymmetricMatrix
		{
			public double m0;

			public double m1;

			public double m2;

			public double m3;

			public double m4;

			public double m5;

			public double m6;

			public double m7;

			public double m8;

			public double m9;

			public SymmetricMatrix(double c)
			{
				m0 = (m1 = (m2 = (m3 = (m4 = (m5 = (m6 = (m7 = (m8 = (m9 = c)))))))));
			}

			public SymmetricMatrix(double a, double b, double c, double d)
			{
				m0 = a * a;
				m1 = a * b;
				m2 = a * c;
				m3 = a * d;
				m4 = b * b;
				m5 = b * c;
				m6 = b * d;
				m7 = c * c;
				m8 = c * d;
				m9 = d * d;
			}

			public static SymmetricMatrix operator +(SymmetricMatrix a, SymmetricMatrix b)
			{
				return new SymmetricMatrix
				{
					m0 = a.m0 + b.m0,
					m1 = a.m1 + b.m1,
					m2 = a.m2 + b.m2,
					m3 = a.m3 + b.m3,
					m4 = a.m4 + b.m4,
					m5 = a.m5 + b.m5,
					m6 = a.m6 + b.m6,
					m7 = a.m7 + b.m7,
					m8 = a.m8 + b.m8,
					m9 = a.m9 + b.m9
				};
			}

			public double Value(Vector3 v)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				return m0 * (double)v.x * (double)v.x + 2.0 * m1 * (double)v.x * (double)v.y + 2.0 * m2 * (double)v.x * (double)v.z + 2.0 * m3 * (double)v.x + m4 * (double)v.y * (double)v.y + 2.0 * m5 * (double)v.y * (double)v.z + 2.0 * m6 * (double)v.y + m7 * (double)v.z * (double)v.z + 2.0 * m8 * (double)v.z + m9;
			}
		}

		private class SimplifierTriangle
		{
			public int[] U = new int[3];

			public int[] V = new int[3];

			public double[] Err = new double[4];

			public bool Deleted;

			public bool Dirty;

			public Vector3 Normal;

			public int SubmeshIndex;
		}

		private struct SimplifierRef
		{
			public int Tid;

			public int Tvertex;
		}

		public static SerializableMesh Simplify(SerializableMesh original, float quality)
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b79: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b9a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b90: Unknown result type (might be due to invalid IL or missing references)
			//IL_066f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bbd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bb2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0690: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06db: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0704: Unknown result type (might be due to invalid IL or missing references)
			//IL_0763: Unknown result type (might be due to invalid IL or missing references)
			//IL_0765: Unknown result type (might be due to invalid IL or missing references)
			//IL_0781: Unknown result type (might be due to invalid IL or missing references)
			//IL_0789: Unknown result type (might be due to invalid IL or missing references)
			//IL_0790: Unknown result type (might be due to invalid IL or missing references)
			//IL_0795: Unknown result type (might be due to invalid IL or missing references)
			//IL_079a: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0801: Unknown result type (might be due to invalid IL or missing references)
			//IL_0806: Unknown result type (might be due to invalid IL or missing references)
			//IL_0808: Unknown result type (might be due to invalid IL or missing references)
			//IL_080f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0816: Unknown result type (might be due to invalid IL or missing references)
			//IL_081d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0822: Unknown result type (might be due to invalid IL or missing references)
			//IL_0829: Unknown result type (might be due to invalid IL or missing references)
			//IL_0830: Unknown result type (might be due to invalid IL or missing references)
			//IL_0837: Unknown result type (might be due to invalid IL or missing references)
			//IL_083e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0843: Unknown result type (might be due to invalid IL or missing references)
			//IL_0848: Unknown result type (might be due to invalid IL or missing references)
			//IL_084e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0855: Unknown result type (might be due to invalid IL or missing references)
			//IL_085c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0863: Unknown result type (might be due to invalid IL or missing references)
			//IL_086a: Unknown result type (might be due to invalid IL or missing references)
			//IL_086f: Unknown result type (might be due to invalid IL or missing references)
			if (original == null)
			{
				return null;
			}
			if (quality >= 1f || original.Vertices == null || original.Vertices.Length < 12)
			{
				return original;
			}
			int num = 0;
			for (int i = 0; i < original.SubMeshTriangles.Length; i++)
			{
				num += original.SubMeshTriangles[i].Length / 3;
			}
			num = Mathf.Max(4, (int)((float)num * quality));
			Vector3[] array = (Vector3[])original.Vertices.Clone();
			Vector3[] array2 = ((original.Normals != null) ? ((Vector3[])original.Normals.Clone()) : null);
			Vector2[] array3 = ((original.UV != null) ? ((Vector2[])original.UV.Clone()) : null);
			Vector4[] array4 = ((original.Tangents != null) ? ((Vector4[])original.Tangents.Clone()) : null);
			List<Vector3> list = new List<Vector3>();
			int[] array5 = new int[array.Length];
			Dictionary<GridKey, int> dictionary = new Dictionary<GridKey, int>();
			float num2 = 0.0001f;
			for (int j = 0; j < array.Length; j++)
			{
				Vector3 val = array[j];
				GridKey key = new GridKey(Mathf.RoundToInt(val.x / num2), Mathf.RoundToInt(val.y / num2), Mathf.RoundToInt(val.z / num2));
				if (!dictionary.TryGetValue(key, out var value))
				{
					value = list.Count;
					list.Add(val);
					dictionary.Add(key, value);
				}
				array5[j] = value;
			}
			List<int>[] array6 = new List<int>[list.Count];
			for (int k = 0; k < array6.Length; k++)
			{
				array6[k] = new List<int>();
			}
			for (int l = 0; l < array5.Length; l++)
			{
				array6[array5[l]].Add(l);
			}
			List<SimplifierTriangle> triangles = new List<SimplifierTriangle>();
			for (int m = 0; m < original.SubMeshTriangles.Length; m++)
			{
				int[] array7 = original.SubMeshTriangles[m];
				for (int n = 0; n < array7.Length; n += 3)
				{
					if (n + 2 < array7.Length)
					{
						int num3 = array7[n];
						int num4 = array7[n + 1];
						int num5 = array7[n + 2];
						if (num3 >= 0 && num3 < array.Length && num4 >= 0 && num4 < array.Length && num5 >= 0 && num5 < array.Length)
						{
							SimplifierTriangle simplifierTriangle = new SimplifierTriangle
							{
								SubmeshIndex = m
							};
							simplifierTriangle.V[0] = num3;
							simplifierTriangle.V[1] = num4;
							simplifierTriangle.V[2] = num5;
							simplifierTriangle.U[0] = array5[num3];
							simplifierTriangle.U[1] = array5[num4];
							simplifierTriangle.U[2] = array5[num5];
							triangles.Add(simplifierTriangle);
						}
					}
				}
			}
			Dictionary<long, int> dictionary2 = new Dictionary<long, int>();
			foreach (SimplifierTriangle item in triangles)
			{
				for (int num6 = 0; num6 < 3; num6++)
				{
					long edgeKey = GetEdgeKey(item.U[num6], item.U[(num6 + 1) % 3]);
					dictionary2[edgeKey] = ((!dictionary2.TryGetValue(edgeKey, out var value2)) ? 1 : (value2 + 1));
				}
			}
			int[] array8 = new int[list.Count];
			foreach (KeyValuePair<long, int> item2 in dictionary2)
			{
				if (item2.Value == 1)
				{
					int num7 = (int)(item2.Key >> 32);
					int num8 = (int)(item2.Key & 0xFFFFFFFFu);
					if (num7 >= 0 && num7 < array8.Length)
					{
						array8[num7] = 1;
					}
					if (num8 >= 0 && num8 < array8.Length)
					{
						array8[num8] = 1;
					}
				}
			}
			SymmetricMatrix[] array9 = new SymmetricMatrix[list.Count];
			int num9 = 0;
			int num10 = 10;
			for (int num11 = 0; num11 < num10; num11++)
			{
				RebuildReferences(triangles, list.Count, out var refs, out var vertexRefs, out var vertexCounts);
				if (num11 % 2 == 0)
				{
					RecalculateQuadrics(list, triangles, array9);
				}
				foreach (SimplifierTriangle item3 in triangles)
				{
					if (!item3.Deleted)
					{
						item3.Err[0] = CalculateEdgeError(item3.U[0], item3.U[1], list, array9, array8, out var optimalPos);
						item3.Err[1] = CalculateEdgeError(item3.U[1], item3.U[2], list, array9, array8, out optimalPos);
						item3.Err[2] = CalculateEdgeError(item3.U[2], item3.U[0], list, array9, array8, out optimalPos);
						item3.Err[3] = Math.Min(item3.Err[0], Math.Min(item3.Err[1], item3.Err[2]));
					}
				}
				List<int> list2 = new List<int>();
				for (int num12 = 0; num12 < triangles.Count; num12++)
				{
					if (!triangles[num12].Deleted)
					{
						list2.Add(num12);
					}
				}
				list2.Sort((int a, int b) => triangles[a].Err[3].CompareTo(triangles[b].Err[3]));
				bool[] array10 = new bool[list.Count];
				for (int num13 = 0; num13 < array10.Length; num13++)
				{
					array10[num13] = true;
				}
				int num14 = 0;
				foreach (int item4 in list2)
				{
					SimplifierTriangle simplifierTriangle2 = triangles[item4];
					if (simplifierTriangle2.Deleted)
					{
						continue;
					}
					int num15 = 0;
					if (simplifierTriangle2.Err[1] < simplifierTriangle2.Err[0] && simplifierTriangle2.Err[1] < simplifierTriangle2.Err[2])
					{
						num15 = 1;
					}
					if (simplifierTriangle2.Err[2] < simplifierTriangle2.Err[0] && simplifierTriangle2.Err[2] < simplifierTriangle2.Err[1])
					{
						num15 = 2;
					}
					int num16 = simplifierTriangle2.U[num15];
					int num17 = simplifierTriangle2.U[(num15 + 1) % 3];
					if (num16 == num17 || !array10[num16] || !array10[num17])
					{
						continue;
					}
					if (array8[num16] == 1 && array8[num17] == 0)
					{
						int num18 = num16;
						num16 = num17;
						num17 = num18;
					}
					CalculateEdgeError(num16, num17, list, array9, array8, out var optimalPos2);
					if (WouldFlip(num16, num17, optimalPos2, list, triangles, refs, vertexRefs, vertexCounts[num17]))
					{
						continue;
					}
					list[num16] = optimalPos2;
					array9[num16] += array9[num17];
					array10[num16] = false;
					array10[num17] = false;
					float num19 = 0.5f;
					Vector3 val2 = list[num16];
					Vector3 val3 = list[num17] - val2;
					float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
					if (sqrMagnitude > 1E-06f)
					{
						num19 = Vector3.Dot(optimalPos2 - val2, val3) / sqrMagnitude;
						num19 = Mathf.Clamp01(num19);
					}
					List<int> list3 = array6[num16];
					List<int> list4 = array6[num17];
					if (list3.Count == 0 || list4.Count == 0)
					{
						continue;
					}
					foreach (int item5 in list4)
					{
						int num20 = list3[0];
						array[item5] = optimalPos2;
						if (array2 != null && num20 < array2.Length && item5 < array2.Length)
						{
							array2[item5] = Vector3.Normalize(Vector3.Lerp(array2[num20], array2[item5], num19));
						}
						if (array3 != null && num20 < array3.Length && item5 < array3.Length)
						{
							array3[item5] = Vector2.Lerp(array3[num20], array3[item5], num19);
						}
						if (array4 != null && num20 < array4.Length && item5 < array4.Length)
						{
							Vector4 val4 = array4[num20];
							Vector4 val5 = array4[item5];
							Vector3 val6 = Vector3.Normalize(Vector3.Lerp(new Vector3(val4.x, val4.y, val4.z), new Vector3(val5.x, val5.y, val5.z), num19));
							array4[item5] = new Vector4(val6.x, val6.y, val6.z, val4.w);
						}
						list3.Add(item5);
					}
					foreach (int item6 in list3)
					{
						array[item6] = optimalPos2;
					}
					list4.Clear();
					int num21 = vertexCounts[num17];
					for (int num22 = 0; num22 < num21; num22++)
					{
						int num23 = vertexRefs[num17] + num22;
						if (num23 < 0 || num23 >= refs.Length)
						{
							continue;
						}
						SimplifierRef simplifierRef = refs[num23];
						if (simplifierRef.Tid >= 0 && simplifierRef.Tid < triangles.Count)
						{
							SimplifierTriangle simplifierTriangle3 = triangles[simplifierRef.Tid];
							if (!simplifierTriangle3.Deleted)
							{
								simplifierTriangle3.U[simplifierRef.Tvertex] = num16;
								simplifierTriangle3.V[simplifierRef.Tvertex] = list3[0];
								simplifierTriangle3.Dirty = true;
							}
						}
					}
					for (int num24 = 0; num24 < num21; num24++)
					{
						int num25 = vertexRefs[num17] + num24;
						if (num25 < 0 || num25 >= refs.Length)
						{
							continue;
						}
						SimplifierRef simplifierRef2 = refs[num25];
						if (simplifierRef2.Tid >= 0 && simplifierRef2.Tid < triangles.Count)
						{
							SimplifierTriangle simplifierTriangle4 = triangles[simplifierRef2.Tid];
							if (!simplifierTriangle4.Deleted && (simplifierTriangle4.U[0] == simplifierTriangle4.U[1] || simplifierTriangle4.U[1] == simplifierTriangle4.U[2] || simplifierTriangle4.U[2] == simplifierTriangle4.U[0]))
							{
								simplifierTriangle4.Deleted = true;
								num9++;
							}
						}
					}
					num14++;
					if (triangles.Count - num9 <= num)
					{
						break;
					}
				}
				if (num14 == 0)
				{
					break;
				}
			}
			List<Vector3> list5 = new List<Vector3>();
			List<Vector3> list6 = ((original.Normals != null) ? new List<Vector3>() : null);
			List<Vector2> list7 = ((original.UV != null) ? new List<Vector2>() : null);
			List<Vector4> list8 = ((original.Tangents != null) ? new List<Vector4>() : null);
			int[] array11 = new int[array.Length];
			for (int num26 = 0; num26 < array11.Length; num26++)
			{
				array11[num26] = -1;
			}
			List<int>[] array12 = new List<int>[original.SubMeshTriangles.Length];
			for (int num27 = 0; num27 < array12.Length; num27++)
			{
				array12[num27] = new List<int>();
			}
			foreach (SimplifierTriangle item7 in triangles)
			{
				if (item7.Deleted)
				{
					continue;
				}
				for (int num28 = 0; num28 < 3; num28++)
				{
					int num29 = item7.V[num28];
					int num30 = array11[num29];
					if (num30 == -1)
					{
						num30 = (array11[num29] = list5.Count);
						list5.Add(array[num29]);
						list6?.Add((num29 < array2.Length) ? array2[num29] : Vector3.up);
						list7?.Add((num29 < array3.Length) ? array3[num29] : Vector2.zero);
						list8?.Add((num29 < array4.Length) ? array4[num29] : Vector4.zero);
					}
					array12[item7.SubmeshIndex].Add(num30);
				}
			}
			int[][] array13 = new int[original.SubMeshTriangles.Length][];
			for (int num31 = 0; num31 < array13.Length; num31++)
			{
				array13[num31] = array12[num31].ToArray();
			}
			return new SerializableMesh
			{
				Name = original.Name + "_LOD",
				Vertices = list5.ToArray(),
				Normals = list6?.ToArray(),
				UV = list7?.ToArray(),
				Tangents = list8?.ToArray(),
				SubMeshTriangles = array13
			};
		}

		private static long GetEdgeKey(int u1, int u2)
		{
			if (u1 >= u2)
			{
				return ((long)u2 << 32) | (uint)u1;
			}
			return ((long)u1 << 32) | (uint)u2;
		}

		private static void RecalculateQuadrics(List<Vector3> uniquePositions, List<SimplifierTriangle> triangles, SymmetricMatrix[] uniqueQuadrics)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < uniqueQuadrics.Length; i++)
			{
				uniqueQuadrics[i] = new SymmetricMatrix(0.0);
			}
			foreach (SimplifierTriangle triangle in triangles)
			{
				if (!triangle.Deleted)
				{
					Vector3 val = uniquePositions[triangle.U[0]];
					Vector3 val2 = uniquePositions[triangle.U[1]];
					Vector3 val3 = uniquePositions[triangle.U[2]];
					Vector3 val4 = Vector3.Cross(val2 - val, val3 - val);
					Vector3 val5 = (triangle.Normal = ((Vector3)(ref val4)).normalized);
					double a = val5.x;
					double b = val5.y;
					double c = val5.z;
					double d = 0f - Vector3.Dot(val5, val);
					SymmetricMatrix symmetricMatrix = new SymmetricMatrix(a, b, c, d);
					uniqueQuadrics[triangle.U[0]] += symmetricMatrix;
					uniqueQuadrics[triangle.U[1]] += symmetricMatrix;
					uniqueQuadrics[triangle.U[2]] += symmetricMatrix;
				}
			}
		}

		private static void RebuildReferences(List<SimplifierTriangle> triangles, int uniqueVertexCount, out SimplifierRef[] refs, out int[] vertexRefs, out int[] vertexCounts)
		{
			vertexCounts = new int[uniqueVertexCount];
			foreach (SimplifierTriangle triangle in triangles)
			{
				if (!triangle.Deleted)
				{
					vertexCounts[triangle.U[0]]++;
					vertexCounts[triangle.U[1]]++;
					vertexCounts[triangle.U[2]]++;
				}
			}
			vertexRefs = new int[uniqueVertexCount];
			int num = 0;
			for (int i = 0; i < uniqueVertexCount; i++)
			{
				vertexRefs[i] = num;
				num += vertexCounts[i];
			}
			refs = new SimplifierRef[num];
			int[] array = new int[uniqueVertexCount];
			for (int j = 0; j < triangles.Count; j++)
			{
				SimplifierTriangle simplifierTriangle = triangles[j];
				if (!simplifierTriangle.Deleted)
				{
					for (int k = 0; k < 3; k++)
					{
						int num2 = simplifierTriangle.U[k];
						int num3 = vertexRefs[num2] + array[num2];
						refs[num3] = new SimplifierRef
						{
							Tid = j,
							Tvertex = k
						};
						array[num2]++;
					}
				}
			}
		}

		private static double CalculateEdgeError(int u1, int u2, List<Vector3> uniquePositions, SymmetricMatrix[] uniqueQuadrics, int[] uniqueBoundary, out Vector3 optimalPos)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			SymmetricMatrix q = uniqueQuadrics[u1] + uniqueQuadrics[u2];
			bool flag = u1 >= 0 && u1 < uniqueBoundary.Length && uniqueBoundary[u1] == 1;
			bool flag2 = u2 >= 0 && u2 < uniqueBoundary.Length && uniqueBoundary[u2] == 1;
			Vector3 val = uniquePositions[u1];
			Vector3 val2 = uniquePositions[u2];
			if (flag && flag2)
			{
				optimalPos = (val + val2) * 0.5f;
				return q.Value(optimalPos) * 2.0;
			}
			if (flag)
			{
				optimalPos = val;
				return q.Value(optimalPos) * 10.0;
			}
			if (flag2)
			{
				optimalPos = val2;
				return q.Value(optimalPos) * 10.0;
			}
			return CalculateError(q, val, val2, out optimalPos);
		}

		private static double CalculateError(SymmetricMatrix q, Vector3 v1, Vector3 v2, out Vector3 result)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (SolveOptimalVertex(q, out result))
			{
				return q.Value(result);
			}
			Vector3 val = (v1 + v2) * 0.5f;
			double num = q.Value(v1);
			double num2 = q.Value(v2);
			double num3 = q.Value(val);
			double num4 = num;
			result = v1;
			if (num2 < num4)
			{
				num4 = num2;
				result = v2;
			}
			if (num3 < num4)
			{
				num4 = num3;
				result = val;
			}
			return num4;
		}

		private static bool SolveOptimalVertex(SymmetricMatrix q, out Vector3 result)
		{
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			double num = q.m0 * (q.m4 * q.m7 - q.m5 * q.m5) - q.m1 * (q.m1 * q.m7 - q.m5 * q.m2) + q.m2 * (q.m1 * q.m5 - q.m4 * q.m2);
			if (Math.Abs(num) > 1E-06)
			{
				double num2 = 1.0 / num;
				result.x = (float)(num2 * ((0.0 - q.m3) * (q.m4 * q.m7 - q.m5 * q.m5) - q.m1 * ((0.0 - q.m6) * q.m7 - q.m5 * (0.0 - q.m8)) + q.m2 * ((0.0 - q.m6) * q.m5 - q.m4 * (0.0 - q.m8))));
				result.y = (float)(num2 * (q.m0 * ((0.0 - q.m6) * q.m7 - q.m5 * (0.0 - q.m8)) - (0.0 - q.m3) * (q.m1 * q.m7 - q.m5 * q.m2) + q.m2 * (q.m1 * (0.0 - q.m8) - (0.0 - q.m6) * q.m2)));
				result.z = (float)(num2 * (q.m0 * (q.m4 * (0.0 - q.m8) - q.m5 * (0.0 - q.m6)) - q.m1 * (q.m1 * (0.0 - q.m8) - q.m2 * (0.0 - q.m6)) + (0.0 - q.m3) * (q.m1 * q.m5 - q.m4 * q.m2)));
				return true;
			}
			result = Vector3.zero;
			return false;
		}

		private static bool WouldFlip(int u1, int u2, Vector3 newPos, List<Vector3> uniquePositions, List<SimplifierTriangle> triangles, SimplifierRef[] refs, int[] vertexRefs, int tCount)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < tCount; i++)
			{
				int num = vertexRefs[u2] + i;
				if (num < 0 || num >= refs.Length)
				{
					continue;
				}
				SimplifierRef simplifierRef = refs[num];
				if (simplifierRef.Tid < 0 || simplifierRef.Tid >= triangles.Count)
				{
					continue;
				}
				SimplifierTriangle simplifierTriangle = triangles[simplifierRef.Tid];
				if (simplifierTriangle.Deleted)
				{
					continue;
				}
				int tvertex = simplifierRef.Tvertex;
				int num2 = simplifierTriangle.U[(tvertex + 1) % 3];
				int num3 = simplifierTriangle.U[(tvertex + 2) % 3];
				if (num2 != u1 && num3 != u1 && num2 >= 0 && num2 < uniquePositions.Count && num3 >= 0 && num3 < uniquePositions.Count)
				{
					Vector3 val = uniquePositions[num2];
					Vector3 val2 = uniquePositions[num3];
					Vector3 val3 = Vector3.Cross(val - uniquePositions[u2], val2 - uniquePositions[u2]);
					Vector3 normalized = ((Vector3)(ref val3)).normalized;
					val3 = Vector3.Cross(val - newPos, val2 - newPos);
					Vector3 normalized2 = ((Vector3)(ref val3)).normalized;
					if (Vector3.Dot(normalized, normalized2) < 0.1f)
					{
						return true;
					}
				}
			}
			return false;
		}
	}
	[HarmonyPatch]
	public static class SmokePatch
	{
		private struct CachedSmokeData
		{
			public Rigidbody Body;

			public bool KinematicFixed;

			public float LastMassUpdate;

			public int UpdateCount;

			public Vector3 Vel;

			public float Force;

			public float Ttl;

			public float Time;
		}

		private static readonly Func<Smoke, Rigidbody> _getBody;

		private static readonly Func<Smoke, float> _getTime;

		private static readonly Func<Smoke, float> _getTtl;

		private static readonly Func<Smoke, float> _getFadeTimer;

		private static readonly Func<Smoke, float> _getFadetime;

		private static readonly Func<Smoke, Vector3> _getVel;

		private static readonly Func<Smoke, float> _getForce;

		private static readonly Action<Smoke, float> _setTime;

		private static readonly Action<Smoke, float> _setFadeTimer;

		private static readonly Action<Smoke> _startFadeOut;

		private static readonly bool _delegatesReady;

		private static readonly Dictionary<Smoke, CachedSmokeData> _cache;

		private const float _massUpdateInterval = 0.1f;

		private const int _forceEveryNFrames = 3;

		static SmokePatch()
		{
			_cache = new Dictionary<Smoke, CachedSmokeData>(64);
			try
			{
				_getBody = BuildGetter<Smoke, Rigidbody>("m_body");
				_getTime = BuildGetter<Smoke, float>("m_time");
				_getTtl = BuildGetter<Smoke, float>("m_ttl");
				_getFadeTimer = BuildGetter<Smoke, float>("m_fadeTimer");
				_getFadetime = BuildGetter<Smoke, float>("m_fadetime");
				_getVel = BuildGetter<Smoke, Vector3>("m_vel");
				_getForce = BuildGetter<Smoke, float>("m_force");
				_setTime = BuildSetter<Smoke, float>("m_time");
				_setFadeTimer = BuildSetter<Smoke, float>("m_fadeTimer");
				_startFadeOut = BuildMethodCaller<Smoke>("StartFadeOut");
				_delegatesReady = _getBody != null && _getTime != null && _getTtl != null && _setTime != null && _getVel != null && _getForce != null && _startFadeOut != null;
				if (!_delegatesReady)
				{
					Plugin.Log.LogWarning((object)"[SmokePatch] Core fields not found — patch disabled.");
				}
				else
				{
					Plugin.Log.LogInfo((object)"[SmokePatch] Delegates compiled successfully (v2.9.2).");
				}
			}
			catch (Exception ex)
			{
				_delegatesReady = false;
				Plugin.Log.LogError((object)("[SmokePatch] Failed to compile delegates: " + ex.Message));
			}
		}

		private static Func<TInstance, TField> BuildGetter<TInstance, TField>(string fieldName)
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(TInstance), fieldName);
			if (fieldInfo == null)
			{
				return null;
			}
			ParameterExpression parameterExpression = Expression.Parameter(typeof(TInstance), "instance");
			return Expression.Lambda<Func<TInstance, TField>>(Expression.Field(parameterExpression, fieldInfo), new ParameterExpression[1] { parameterExpression }).Compile();
		}

		private static Action<TInstance, TField> BuildSetter<TInstance, TField>(string fieldName)
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(TInstance), fieldName);
			if (fieldInfo == null)
			{
				return null;
			}
			ParameterExpression parameterExpression = Expression.Parameter(typeof(TInstance), "instance");
			ParameterExpression parameterExpression2 = Expression.Parameter(typeof(TField), "value");
			return Expression.Lambda<Action<TInstance, TField>>(Expression.Assign(Expression.Field(parameterExpression, fieldInfo), parameterExpression2), new ParameterExpression[2] { parameterExpression, parameterExpression2 }).Compile();
		}

		private static Action<TInstance> BuildMethodCaller<TInstance>(string methodName)
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(TInstance), methodName, (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				return null;
			}
			ParameterExpression parameterExpression = Expression.Parameter(typeof(TInstance), "instance");
			return Expression.Lambda<Action<TInstance>>(Expression.Call(parameterExpression, methodInfo), new ParameterExpression[1] { parameterExpression }).Compile();
		}

		[HarmonyPatch(typeof(Smoke), "CustomUpdate")]
		[HarmonyPrefix]
		private static bool Smoke_CustomUpdate_Prefix(Smoke __instance, float deltaTime)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.SmokeOptimizationEnabled.Value)
			{
				return true;
			}
			if (!_delegatesReady)
			{
				return true;
			}
			if (!_cache.TryGetValue(__instance, out var value))
			{
				Rigidbody val = _getBody(__instance);
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				value = new CachedSmokeData
				{
					Body = val,
					KinematicFixed = false,
					LastMassUpdate = 0f,
					UpdateCount = 0,
					Vel = _getVel(__instance),
					Force = _getForce(__instance),
					Ttl = _getTtl(__instance),
					Time = _getTime(__instance)
				};
			}
			Rigidbody body = value.Body;
			if ((Object)(object)body == (Object)null)
			{
				_cache.Remove(__instance);
				return true;
			}
			if (!value.KinematicFixed)
			{
				if (body.isKinematic)
				{
					body.isKinematic = false;
				}
				value.KinematicFixed = true;
			}
			if (value.Ttl <= 0f)
			{
				return false;
			}
			float num = Mathf.Clamp01(1f - value.Time / value.Ttl);
			float num2 = num * num;
			float time = Time.time;
			if (time - value.LastMassUpdate >= 0.1f)
			{
				body.mass = Mathf.Max(num2, 0.001f);
				value.LastMassUpdate = time;
			}
			value.UpdateCount++;
			if (value.UpdateCount % 3 == 0)
			{
				Vector3 velocity = body.velocity;
				Vector3 vel = value.Vel;
				vel.y *= num;
				Vector3 val2 = vel - velocity;
				body.AddForce(val2 * (value.Force * deltaTime * 3f), (ForceMode)2);
			}
			value.Time += deltaTime;
			_setTime(__instance, value.Time);
			if (value.Time >= value.Ttl && _getFadeTimer != null && _getFadetime != null && _setFadeTimer != null)
			{
				float num3 = _getFadeTimer(__instance);
				if (num3 < 0f && _startFadeOut != null)
				{
					_startFadeOut(__instance);
					num3 = 0f;
				}
				if (num3 >= 0f)
				{
					num3 += deltaTime;
					_setFadeTimer(__instance, num3);
					float num4 = _getFadetime(__instance);
					if (num3 >= num4)
					{
						_cache.Remove(__instance);
						Object.Destroy((Object)(object)((Component)__instance).gameObject);
						return false;
					}
				}
			}
			_cache[__instance] = value;
			return false;
		}

		[HarmonyPatch(typeof(Smoke), "OnDestroy")]
		[HarmonyPostfix]
		private static void Smoke_OnDestroy_Postfix(Smoke __instance)
		{
			_cache.Remove(__instance);
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	[HarmonyPriority(200)]
	public static class TorchOptimizer
	{
		private const float GRAVITY_MODIFIER = -0.3f;

		private static readonly string[] TargetPrefabs = new string[5] { "piece_groundtorch", "piece_walltorch", "piece_brazier", "piece_groundtorch_green", "piece_groundtorch_blue" };

		[HarmonyPostfix]
		public static void Postfix(ZNetScene __instance)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.ParticleOptimizationEnabled.Value)
			{
				return;
			}
			float num = Plugin.TorchParticleLifetime?.Value ?? 0.8f;
			int num2 = 0;
			string[] targetPrefabs = TargetPrefabs;
			foreach (string text in targetPrefabs)
			{
				GameObject prefab = __instance.GetPrefab(text);
				if (!((Object)(object)prefab == (Object)null))
				{
					ParticleSystem[] componentsInChildren = prefab.GetComponentsInChildren<ParticleSystem>(true);
					for (int j = 0; j < componentsInChildren.Length; j++)
					{
						MainModule main = componentsInChildren[j].main;
						((MainModule)(ref main)).startLifetime = MinMaxCurve.op_Implicit(num);
						((MainModule)(ref main)).gravityModifier = MinMaxCurve.op_Implicit(-0.3f);
						num2++;
					}
				}
			}
			if (Plugin.DebugLoggingEnabled.Value && num2 > 0)
			{
				Plugin.Log.LogInfo((object)$"[TorchOptimizer] Patched {num2} particle systems across torch prefabs.");
			}
		}
	}
}
namespace ValheimPerformanceOverhaul.Network
{
	public class SmartZoneManager : MonoBehaviour
	{
		private float _updateTimer;

		public static SmartZoneManager Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		private void Update()
		{
			if (Plugin.SmartZoneOwnershipEnabled.Value && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				_updateTimer += Time.deltaTime;
				if (!(_updateTimer < Plugin.ZoneUpdateInterval.Value))
				{
					_updateTimer = 0f;
					OptimizeZoneOwnerships();
				}
			}
		}

		private void OptimizeZoneOwnerships()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			List<ZNetPeer> peers = ZNet.instance.GetPeers();
			if (peers == null || peers.Count < 2)
			{
				return;
			}
			Dictionary<Vector2i, List<ZNetPeer>> dictionary = new Dictionary<Vector2i, List<ZNetPeer>>();
			foreach (ZNetPeer item in peers)
			{
				if (item != null && item.IsReady())
				{
					Vector2i zone = ZoneSystem.GetZone(item.GetRefPos());
					if (!dictionary.ContainsKey(zone))
					{
						dictionary[zone] = new List<ZNetPeer>();
					}
					dictionary[zone].Add(item);
				}
			}
			int value = Plugin.ZonePingThreshold.Value;
			int value2 = Plugin.ZonePingHysteresis.Value;
			foreach (KeyValuePair<Vector2i, List<ZNetPeer>> item2 in dictionary)
			{
				if (item2.Value.Count < 2)
				{
					continue;
				}
				Vector2i key = item2.Key;
				ZNetPeer val = null;
				int num = int.MaxValue;
				foreach (ZNetPeer item3 in item2.Value)
				{
					int playerPingMs = GetPlayerPingMs(item3);
					if (playerPingMs > 0 && playerPingMs < num)
					{
						num = playerPingMs;
						val = item3;
					}
				}
				if (val == null)
				{
					continue;
				}
				long currentOwnerUid = GetSectorOwner(key);
				if (currentOwnerUid != 0L && currentOwnerUid != val.m_uid)
				{
					ZNetPeer val2 = item2.Value.Find((ZNetPeer p) => p.m_uid == currentOwnerUid);
					int num2 = ((val2 != null) ? GetPlayerPingMs(val2) : int.MaxValue);
					if (num2 > value && num2 - num > value2)
					{
						TransferZoneObjects(key, val.m_uid);
					}
				}
			}
		}

		private int GetPlayerPingMs(ZNetPeer peer)
		{
			if (peer == null || peer.m_rpc == null)
			{
				return -1;
			}
			float timeSinceLastPing = peer.m_rpc.GetTimeSinceLastPing();
			if (!(timeSinceLastPing < 10f))
			{
				return -1;
			}
			return (int)(timeSinceLastPing * 1000f);
		}

		private long GetSectorOwner(Vector2i sector)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			List<Character> allCharacters = Character.GetAllCharacters();
			for (int i = 0; i < allCharacters.Count; i++)
			{
				Character val = allCharacters[i];
				if (!((Object)(object)val == (Object)null) && !val.IsPlayer() && ZoneSystem.GetZone(((Component)val).transform.position) == sector)
				{
					ZNetView component = ((Component)val).GetComponent<ZNetView>();
					if ((Object)(object)component != (Object)null && component.IsValid() && component.GetZDO() != null)
					{
						return component.GetZDO().GetOwner();
					}
				}
			}
			return 0L;
		}

		private void TransferZoneObjects(Vector2i sector, long newOwnerUid)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			List<Character> allCharacters = Character.GetAllCharacters();
			for (int i = 0; i < allCharacters.Count; i++)
			{
				Character val = allCharacters[i];
				if (!((Object)(object)val == (Object)null) && !val.IsPlayer() && ZoneSystem.GetZone(((Component)val).transform.position) == sector)
				{
					ZNetView component = ((Component)val).GetComponent<ZNetView>();
					if ((Object)(object)component != (Object)null && component.IsValid() && component.IsOwner())
					{
						component.GetZDO().SetOwner(newOwnerUid);
					}
				}
			}
		}
	}
	[HarmonyPatch]
	public static class SmartZoneInitPatch
	{
		[HarmonyPatch(typeof(ZNet), "Awake")]
		[HarmonyPostfix]
		private static void ZNet_Awake_Postfix(ZNet __instance)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.SmartZoneOwnershipEnabled.Value && (Object)(object)SmartZoneManager.Instance == (Object)null)
			{
				new GameObject("_VPO_SmartZoneManager").AddComponent<SmartZoneManager>();
			}
		}
	}
	public static class NetworkManager
	{
		public static ConfigEntry<bool> EnableNetworkOptimizations;

		public static ConfigEntry<bool> UncapSteamSocket;

		public static ConfigEntry<int> SteamSendRateMinKB;

		public static ConfigEntry<int> SteamSendRateMaxKB;

		public static ConfigEntry<bool> EnableSmartZDOSorting;

		public static ConfigEntry<bool> EnableAdaptiveThrottling;

		public static void SetupConfigs(ConfigFile config)
		{
			EnableNetworkOptimizations = config.Bind<bool>("14. Network Optimization", "Enabled", true, "Включает модуль сетевых оптимизаций (безопасно для кроссплея).");
			UncapSteamSocket = config.Bind<bool>("14. Network Optimization", "Uncap Steam Socket", true, "Увеличивает лимиты передачи данных Steam. Решает проблему лагов на больших базах. Работает только у Steam-клиентов.");
			SteamSendRateMinKB = config.Bind<int>("14. Network Optimization", "Steam Send Rate Min (KB)", 256, "Минимальная скорость (ваниль: 153)");
			SteamSendRateMaxKB = config.Bind<int>("14. Network Optimization", "Steam Send Rate Max (KB)", 2048, "Максимальная скорость (ваниль: 153)");
			EnableSmartZDOSorting = config.Bind<bool>("14. Network Optimization", "Smart ZDO Sorting", true, "Умная приоритезация: игроки и корабли синхронизируются первыми, дальние мобы - последними. Убирает десинки.");
			EnableAdaptiveThrottling = config.Bind<bool>("14. Network Optimization", "Adaptive Throttling", true, "Автоматически снижает частоту отправки данных клиентам с высоким пингом, чтобы не 'задушить' их канал.");
		}
	}
	[HarmonyPatch]
	public static class NetworkPatches
	{
		private static MethodInfo _setSteamConfigMethod;

		private static bool _steamUncapReady;

		private static FieldInfo _mPeerField;

		static NetworkPatches()
		{
			TryInitSteamReflection();
		}

		private static void TryInitSteamReflection()
		{
			try
			{
				Type type = Type.GetType("Steamworks.SteamNetworkingUtils, com.rlabrecque.steamworks.net");
				if (type == null)
				{
					Plugin.Log.LogInfo((object)"[Network] SteamNetworkingUtils not found — Steam uncap disabled (non-Steam build?).");
					return;
				}
				_setSteamConfigMethod = type.GetMethod("SetConfigValue", BindingFlags.Static | BindingFlags.Public);
				if (_setSteamConfigMethod == null)
				{
					Plugin.Log.LogWarning((object)"[Network] SetConfigValue method not found in SteamNetworkingUtils — API may have changed.");
					return;
				}
				_steamUncapReady = true;
				Plugin.Log.LogInfo((object)"[Network] Steam reflection initialized successfully.");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Network] Failed to initialize Steam reflection: " + ex.Message));
				_steamUncapReady = false;
			}
		}

		[HarmonyPatch(typeof(ZSteamSocket), "RegisterGlobalCallbacks")]
		[HarmonyPostfix]
		private static void UncapSteamSocket_Postfix()
		{
			if (!NetworkManager.EnableNetworkOptimizations.Value || !NetworkManager.UncapSteamSocket.Value || !_steamUncapReady)
			{
				return;
			}
			try
			{
				int num = Math.Max(64, NetworkManager.SteamSendRateMinKB.Value) * 1024;
				int num2 = Math.Max(num, NetworkManager.SteamSendRateMaxKB.Value) * 1024;
				int value = 5242880;
				ApplySteamConfig(10, num);
				ApplySteamConfig(11, num2);
				ApplySteamConfig(9, value);
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)$"[Network] Steam uncapped: Min={num / 1024}KB/s, Max={num2 / 1024}KB/s, Buf=5MB");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Network] Steam uncap failed (safe to ignore on non-Steam builds): " + ex.Message));
				_steamUncapReady = false;
			}
		}

		private static void ApplySteamConfig(int configKey, int value)
		{
			GCHandle gCHandle = GCHandle.Alloc(value, GCHandleType.Pinned);
			try
			{
				_setSteamConfigMethod.Invoke(null, new object[5]
				{
					configKey,
					1,
					IntPtr.Zero,
					1,
					gCHandle.AddrOfPinnedObject()
				});
			}
			finally
			{
				gCHandle.Free();
			}
		}

		[HarmonyPatch(typeof(ZDOMan), "SendZDOs")]
		[HarmonyPrefix]
		private static bool AdaptiveThrottling_Prefix(object peer)
		{
			if (!NetworkManager.EnableNetworkOptimizations.Value || !NetworkManager.EnableAdaptiveThrottling.Value)
			{
				return true;
			}
			if (peer == null)
			{
				return true;
			}
			if (_mPeerField == null)
			{
				_mPeerField = AccessTools.Field(peer.GetType(), "m_peer");
				if (_mPeerField == null)
				{
					Plugin.Log.LogWarning((object)"[Network] ZDOPeer.m_peer not found — AdaptiveThrottling disabled.");
					NetworkManager.EnableAdaptiveThrottling.Value = false;
					return true;
				}
			}
			object? value = _mPeerField.GetValue(peer);
			ZNetPeer val = (ZNetPeer)((value is ZNetPeer) ? value : null);
			if (val?.m_rpc == null)
			{
				return true;
			}
			float timeSinceLastPing = val.m_rpc.GetTimeSinceLastPing();
			if (timeSinceLastPing > 5.5f)
			{
				float num = Mathf.Clamp01((timeSinceLastPing - 5.5f) / 1f);
				if (Random.value < num)
				{
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch]
	public static class ZDOOptimizer
	{
		private static readonly int _playerPrefabHash = StringExtensionMethods.GetStableHashCode("Player");

		private static readonly HashSet<int> _highPriorityPrefabs = new HashSet<int>
		{
			StringExtensionMethods.GetStableHashCode("Karve"),
			StringExtensionMethods.GetStableHashCode("VikingShip"),
			StringExtensionMethods.GetStableHashCode("Raft"),
			StringExtensionMethods.GetStableHashCode("VikingShip_Ashlands"),
			StringExtensionMethods.GetStableHashCode("portal_wood"),
			StringExtensionMethods.GetStableHashCode("portal_stone")
		};

		private static readonly int _aiHash = StringExtensionMethods.GetStableHashCode("ai");

		[HarmonyPatch(typeof(ZDOMan), "ServerSortSendZDOS")]
		[HarmonyPriority(600)]
		[HarmonyPrefix]
		private static void ServerSortSendZDOS_Prefix(List<ZDO> objects, Vector3 refPos)
		{
			if (!NetworkManager.EnableNetworkOptimizations.Value || !NetworkManager.EnableSmartZDOSorting.Value)
			{
				return;
			}
			for (int i = 0; i < objects.Count; i++)
			{
				ZDO val = objects[i];
				if (val != null)
				{
					int prefab = val.GetPrefab();
					if (prefab == _playerPrefabHash)
					{
						val.m_tempSortValue -= 10000f;
					}
					else if (_highPriorityPrefabs.Contains(prefab))
					{
						val.m_tempSortValue -= 5000f;
					}
					else if (val.GetInt(_aiHash, 0) != 0)
					{
						val.m_tempSortValue += 300f;
					}
				}
			}
		}
	}
}
namespace ValheimPerformanceOverhaul.Graphics
{
	[HarmonyPatch]
	public static class EngineQualityPatch
	{
		private static bool _applied;

		[HarmonyPatch(typeof(GameCamera), "Awake")]
		[HarmonyPostfix]
		private static void ApplyEngineQualitySettings()
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.EngineQualitySettingsEnabled.Value || _applied)
			{
				return;
			}
			_applied = true;
			try
			{
				QualitySettings.softParticles = false;
				QualitySettings.softVegetation = false;
				QualitySettings.particleRaycastBudget = Plugin.ParticleRaycastBudget.Value;
				switch (Plugin.ConfigSkinWeights.Value)
				{
				case 1:
					QualitySettings.skinWeights = (SkinWeights)1;
					break;
				case 2:
					QualitySettings.skinWeights = (SkinWeights)2;
					break;
				case 4:
					QualitySettings.skinWeights = (SkinWeights)4;
					break;
				default:
					QualitySettings.skinWeights = (SkinWeights)2;
					break;
				}
				Physics.autoSyncTransforms = false;
				QualitySettings.asyncUploadTimeSlice = 2;
				QualitySettings.asyncUploadBufferSize = 64;
				Plugin.Log.LogInfo((object)$"[EngineQuality] Applied optimizations (autoSyncTransforms=false, SkinWeights={QualitySettings.skinWeights}).");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[EngineQuality] Failed to apply settings: " + ex.Message));
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[HarmonyPostfix]
		private static void ResetAppliedFlag()
		{
			_applied = false;
		}
	}
	public static class GPUInstancingManager
	{
		private struct MaterialKey : IEquatable<MaterialKey>
		{
			public readonly Shader Shader;

			public readonly int RenderQueue;

			public readonly Texture MainTex;

			public readonly Texture BumpMap;

			public readonly Color Color;

			public readonly string Keywords;

			public MaterialKey(Material mat)
			{
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				Shader = mat.shader;
				RenderQueue = mat.renderQueue;
				MainTex = (mat.HasProperty("_MainTex") ? mat.GetTexture("_MainTex") : null);
				BumpMap = (mat.HasProperty("_BumpMap") ? mat.GetTexture("_BumpMap") : null);
				Color = (mat.HasProperty("_Color") ? mat.GetColor("_Color") : Color.white);
				if (mat.shaderKeywords != null && mat.shaderKeywords.Length != 0)
				{
					List<string> list = new List<string>(mat.shaderKeywords);
					list.Sort();
					Keywords = string.Join(",", list);
				}
				else
				{
					Keywords = string.Empty;
				}
			}

			public bool Equals(MaterialKey other)
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				if (object.Equals(Shader, other.Shader) && RenderQueue == other.RenderQueue && object.Equals(MainTex, other.MainTex) && object.Equals(BumpMap, other.BumpMap))
				{
					Color color = Color;
					if (((Color)(ref color)).Equals(other.Color))
					{
						return Keywords == other.Keywords;
					}
				}
				return false;
			}

			public override bool Equals(object obj)
			{
				if (obj is MaterialKey other)
				{
					return Equals(other);
				}
				return false;
			}

			public override int GetHashCode()
			{
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				return ((((((((((((Object)(object)Shader != (Object)null) ? ((object)Shader).GetHashCode() : 0) * 397) ^ RenderQueue) * 397) ^ (((Object)(object)MainTex != (Object)null) ? ((object)MainTex).GetHashCode() : 0)) * 397) ^ (((Object)(object)BumpMap != (Object)null) ? ((object)BumpMap).GetHashCode() : 0)) * 397) ^ ((object)Color/*cast due to .constrained prefix*/).GetHashCode()) * 397) ^ Keywords.GetHashCode();
			}
		}

		private static readonly Dictionary<MaterialKey, Material> _materialCache = new Dictionary<MaterialKey, Material>();

		private static readonly HashSet<GameObject> _processedPrefabs = new HashSet<GameObject>();

		public static void ProcessPrefabs(IEnumerable<GameObject> prefabs)
		{
			if (prefabs == null)
			{
				return;
			}
			bool value = Plugin.GPUInstancingDeduplicateMaterials.Value;
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			foreach (GameObject prefab in prefabs)
			{
				if ((Object)(object)prefab == (Object)null || !_processedPrefabs.Add(prefab) || OptimizationTierResolver.Resolve(prefab) != OptimizationTier.Instancing)
				{
					continue;
				}
				num++;
				Renderer[] componentsInChildren = prefab.GetComponentsInChildren<Renderer>(true);
				if (componentsInChildren == null || componentsInChildren.Length == 0)
				{
					continue;
				}
				Renderer[] array = componentsInChildren;
				foreach (Renderer val in array)
				{
					if ((Object)(object)val == (Object)null || val is ParticleSystemRenderer)
					{
						continue;
					}
					Material[] sharedMaterials = val.sharedMaterials;
					if (sharedMaterials == null || sharedMaterials.Length == 0)
					{
						continue;
					}
					bool flag = false;
					for (int j = 0; j < sharedMaterials.Length; j++)
					{
						Material val2 = sharedMaterials[j];
						if ((Object)(object)val2 == (Object)null)
						{
							continue;
						}
						if (!val2.enableInstancing)
						{
							val2.enableInstancing = true;
							flag = true;
						}
						if (value)
						{
							Material orCreateDeduplicatedMaterial = GetOrCreateDeduplicatedMaterial(val2);
							if ((Object)(object)orCreateDeduplicatedMaterial != (Object)null && (Object)(object)orCreateDeduplicatedMaterial != (Object)(object)val2)
							{
								sharedMaterials[j] = orCreateDeduplicatedMaterial;
								num3++;
								flag = true;
							}
						}
					}
					if (flag)
					{
						val.sharedMaterials = sharedMaterials;
						num2++;
					}
				}
			}
			if (Plugin.DebugLoggingEnabled.Value && num > 0)
			{
				Plugin.Log.LogInfo((object)($"[GPUInstancing] Processed {num} prefabs ({num2} renderers). " + $"Merged {num3} duplicate materials. Cache size: {_materialCache.Count}"));
			}
		}

		private static Material GetOrCreateDeduplicatedMaterial(Material original)
		{
			if ((Object)(object)original == (Object)null)
			{
				return null;
			}
			MaterialKey key = new MaterialKey(original);
			if (_materialCache.TryGetValue(key, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			original.enableInstancing = true;
			_materialCache[key] = original;
			return original;
		}

		public static void ClearCache()
		{
			_materialCache.Clear();
			_processedPrefabs.Clear();
		}
	}
	[HarmonyPatch]
	public static class InstancingPatches
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void OnZNetSceneAwake(ZNetScene __instance)
		{
			if (Plugin.GPUInstancingEnabled.Value)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)"[GPUInstancing] Processing ZNetScene prefabs...");
				}
				GPUInstancingManager.ProcessPrefabs(__instance.m_prefabs);
			}
		}

		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		[HarmonyPostfix]
		private static void OnObjectDBCopyOtherDB(ObjectDB __instance)
		{
			if (Plugin.GPUInstancingEnabled.Value)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)"[GPUInstancing] Processing ObjectDB item prefabs...");
				}
				GPUInstancingManager.ProcessPrefabs(__instance.m_items);
			}
		}

		[HarmonyPatch(typeof(ClutterSystem), "Awake")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void ClutterSystem_Awake_Postfix(ClutterSystem __instance)
		{
			if (!Plugin.GPUInstancingEnabled.Value)
			{
				return;
			}
			List<Clutter> clutter = __instance.m_clutter;
			if (clutter == null || clutter.Count == 0)
			{
				return;
			}
			List<GameObject> list = new List<GameObject>();
			foreach (Clutter item in clutter)
			{
				if (item != null && (Object)(object)item.m_prefab != (Object)null)
				{
					list.Add(item.m_prefab);
				}
			}
			if (list.Count > 0)
			{
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)$"[GPUInstancing] Processing {list.Count} ClutterSystem prefabs...");
				}
				GPUInstancingManager.ProcessPrefabs(list);
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "OnDestroy")]
		[HarmonyPostfix]
		private static void ClearInstancingCache()
		{
			GPUInstancingManager.ClearCache();
		}
	}
	[HarmonyPatch]
	public static class LightFlickerPatch
	{
		private static readonly Func<LightFlicker, Light> _getLight;

		private static readonly Func<LightFlicker, float> _getBaseIntensity;

		private static readonly bool _delegatesReady;

		static LightFlickerPatch()
		{
			try
			{
				_getLight = BuildGetter<LightFlicker, Light>("m_light");
				_getBaseIntensity = BuildGetter<LightFlicker, float>("m_baseIntensity");
				_delegatesReady = _getLight != null && _getBaseIntensity != null;
				if (!_delegatesReady)
				{
					Plugin.Log.LogWarning((object)"[LightFlicker] One or more fields not found — patch disabled.");
				}
				else
				{
					Plugin.Log.LogInfo((object)"[LightFlicker] Delegates compiled successfully.");
				}
			}
			catch (Exception ex)
			{
				_delegatesReady = false;
				Plugin.Log.LogError((object)("[LightFlicker] Failed to compile delegates: " + ex.Message));
			}
		}

		private static Func<TInstance, TField> BuildGetter<TInstance, TField>(string fieldName)
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(TInstance), fieldName);
			if (fieldInfo == null)
			{
				return null;
			}
			ParameterExpression parameterExpression = Expression.Parameter(typeof(TInstance), "instance");
			return Expression.Lambda<Func<TInstance, TField>>(Expression.Field(parameterExpression, fieldInfo), new ParameterExpression[1] { parameterExpression }).Compile();
		}

		[HarmonyPatch(typeof(LightFlicker), "CustomUpdate")]
		[HarmonyPrefix]
		private static bool LightFlicker_CustomUpdate_Prefix(LightFlicker __instance)
		{
			if (!Plugin.LightFlickerOptimizationEnabled.Value)
			{
				return true;
			}
			if (!_delegatesReady)
			{
				return true;
			}
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			Light val = _getLight(__instance);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			float intensity = _getBaseIntensity(__instance);
			val.intensity = intensity;
			return false;
		}
	}
	public class StaticBatchingManager : MonoBehaviour
	{
		private class SectorBatchGroup
		{
			public Vector2i Sector;

			public List<GameObject> PendingObjects = new List<GameObject>();

			public float LastAddedTime;

			public GameObject BatchRoot;

			public bool IsBatched;
		}

		private readonly Dictionary<Vector2i, SectorBatchGroup> _sectorGroups = new Dictionary<Vector2i, SectorBatchGroup>();

		private float _updateTimer;

		private const float UPDATE_INTERVAL = 0.5f;

		public static StaticBatchingManager Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			Plugin.Log.LogInfo((object)"[StaticBatchingManager] Manager initialized.");
		}

		public void RegisterObject(GameObject go)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)go == (Object)null))
			{
				Vector2i val = (Vector2i)(((Object)(object)ZoneSystem.instance != (Object)null) ? ZoneSystem.GetZone(go.transform.position) : new Vector2i(Mathf.FloorToInt(go.transform.position.x / 64f), Mathf.FloorToInt(go.transform.position.z / 64f)));
				if (!_sectorGroups.TryGetValue(val, out var value))
				{
					value = new SectorBatchGroup
					{
						Sector = val
					};
					_sectorGroups.Add(val, value);
				}
				if (!value.IsBatched && !value.PendingObjects.Contains(go))
				{
					value.PendingObjects.Add(go);
					value.LastAddedTime = Time.time;
				}
			}
		}

		private void Update()
		{
			if (Plugin.StaticBatchingEnabled.Value)
			{
				_updateTimer += Time.deltaTime;
				if (!(_updateTimer < 0.5f))
				{
					_updateTimer = 0f;
					ProcessPendingBatches();
					CleanupEmptyRoots();
				}
			}
		}

		private void ProcessPendingBatches()
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			float time = Time.time;
			float num = Plugin.StaticBatchingSettleCooldown?.Value ?? 2f;
			List<Vector2i> list = null;
			foreach (KeyValuePair<Vector2i, SectorBatchGroup> sectorGroup in _sectorGroups)
			{
				SectorBatchGroup value = sectorGroup.Value;
				if (value.PendingObjects.Count > 0 && !value.IsBatched && time - value.LastAddedTime >= num)
				{
					if (list == null)
					{
						list = new List<Vector2i>();
					}
					list.Add(sectorGroup.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (Vector2i item in list)
			{
				BatchSector(_sectorGroups[item]);
			}
		}

		private void BatchSector(SectorBatchGroup group)
		{
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			List<GameObject> list = new List<GameObject>();
			int num = 0;
			foreach (GameObject pendingObject in group.PendingObjects)
			{
				if ((Object)(object)pendingObject == (Object)null)
				{
					continue;
				}
				MeshRenderer[] componentsInChildren = pendingObject.GetComponentsInChildren<MeshRenderer>(true);
				bool flag = false;
				MeshRenderer[] array = componentsInChildren;
				foreach (MeshRenderer val in array)
				{
					if (!((Object)(object)val == (Object)null) && ((Renderer)val).enabled)
					{
						MeshFilter component = ((Component)val).GetComponent<MeshFilter>();
						if ((Object)(object)component != (Object)null && (Object)(object)component.sharedMesh != (Object)null)
						{
							num += component.sharedMesh.vertexCount;
							flag = true;
						}
					}
				}
				if (flag)
				{
					list.Add(pendingObject);
				}
			}
			group.PendingObjects.Clear();
			if (list.Count == 0)
			{
				return;
			}
			try
			{
				if ((Object)(object)group.BatchRoot == (Object)null)
				{
					group.BatchRoot = new GameObject($"_VPO_StaticBatch_{group.Sector.x}_{group.Sector.y}");
					group.BatchRoot.transform.position = new Vector3((float)group.Sector.x * 64f + 32f, 0f, (float)group.Sector.y * 64f + 32f);
				}
				foreach (GameObject item in list)
				{
					SetStaticRecursively(item);
				}
				StaticBatchingUtility.Combine(list.ToArray(), group.BatchRoot);
				group.IsBatched = true;
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)$"[StaticBatching] Combined {list.Count} static objects in sector {group.Sector} (Vertices: {num})");
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)$"[StaticBatching] Exception during batching sector {group.Sector}: {ex.Message}");
			}
		}

		private void SetStaticRecursively(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			go.isStatic = true;
			for (int i = 0; i < go.transform.childCount; i++)
			{
				Transform child = go.transform.GetChild(i);
				if ((Object)(object)child != (Object)null)
				{
					SetStaticRecursively(((Component)child).gameObject);
				}
			}
		}

		private void CleanupEmptyRoots()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			List<Vector2i> list = null;
			foreach (KeyValuePair<Vector2i, SectorBatchGroup> sectorGroup in _sectorGroups)
			{
				SectorBatchGroup value = sectorGroup.Value;
				if (value.IsBatched && (Object)(object)value.BatchRoot != (Object)null && value.BatchRoot.transform.childCount == 0)
				{
					if (list == null)
					{
						list = new List<Vector2i>();
					}
					list.Add(sectorGroup.Key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (Vector2i item in list)
			{
				ClearSector(item);
			}
		}

		public void ClearSector(Vector2i sector)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (_sectorGroups.TryGetValue(sector, out var value))
			{
				if ((Object)(object)value.BatchRoot != (Object)null)
				{
					Object.Destroy((Object)(object)value.BatchRoot);
				}
				_sectorGroups.Remove(sector);
			}
		}

		public void ClearAll()
		{
			foreach (SectorBatchGroup value in _sectorGroups.Values)
			{
				if ((Object)(object)value.BatchRoot != (Object)null)
				{
					Object.Destroy((Object)(object)value.BatchRoot);
				}
			}
			_sectorGroups.Clear();
		}

		private void OnDestroy()
		{
			ClearAll();
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}
	}
	[HarmonyPatch]
	public static class StaticBatchingPatches
	{
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		[HarmonyPostfix]
		private static void InitializeManagerOnSpawn(Player __instance)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.StaticBatchingEnabled.Value && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer) && !((Object)(object)StaticBatchingManager.Instance != (Object)null))
			{
				new GameObject("_VPO_StaticBatchingManager").AddComponent<StaticBatchingManager>();
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "CreateObject")]
		[HarmonyPostfix]
		private static void OnSceneObjectCreated(GameObject __result)
		{
			if (Plugin.StaticBatchingEnabled.Value && !((Object)(object)StaticBatchingManager.Instance == (Object)null) && !((Object)(object)__result == (Object)null) && OptimizationTierResolver.Resolve(__result) == OptimizationTier.StaticBatching)
			{
				StaticBatchingManager.Instance.RegisterObject(__result);
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "OnDestroy")]
		[HarmonyPostfix]
		private static void OnShutdownCleanup()
		{
			if ((Object)(object)StaticBatchingManager.Instance != (Object)null)
			{
				StaticBatchingManager.Instance.ClearAll();
			}
		}
	}
	public class TextureOptimizer : MonoBehaviour
	{
		private struct TextureProcessingWork
		{
			public Texture2D OriginalTexture;

			public List<MaterialTextureBinding> Targets;
		}

		private struct MaterialTextureBinding
		{
			public Material Material;

			public string PropertyName;
		}

		private static readonly Dictionary<string, Texture2D> _loadedTexturesCache = new Dictionary<string, Texture2D>();

		private readonly Queue<TextureProcessingWork> _processingQueue = new Queue<TextureProcessingWork>();

		private bool _isProcessing;

		private const string TextureCacheSubdir = "Textures";

		private const string CacheHeader = "VPOTEX";

		public static TextureOptimizer Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			Plugin.Log.LogInfo((object)"[TextureOptimizer] Persistent manager initialized successfully.");
		}

		public static void OptimizeSceneTextures(IEnumerable<GameObject> prefabs)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Instance == (Object)null)
			{
				new GameObject("_VPO_TextureOptimizer").AddComponent<TextureOptimizer>();
			}
			((MonoBehaviour)Instance).StartCoroutine(Instance.AnalyzeAndQueueTextures(prefabs));
		}

		private IEnumerator AnalyzeAndQueueTextures(IEnumerable<GameObject> prefabs)
		{
			if (prefabs == null)
			{
				Plugin.Log.LogWarning((object)"[TextureOptimizer] Prefab list is null, aborting scan.");
				yield break;
			}
			float value = Plugin.TextureDownscaleMultiplier.Value;
			int value2 = Plugin.TextureMinSize.Value;
			Plugin.Log.LogInfo((object)$"[TextureOptimizer] Starting texture scan on prefabs (Downscale: {value}, MinSize: {value2})...");
			Dictionary<Texture2D, List<MaterialTextureBinding>> dictionary = new Dictionary<Texture2D, List<MaterialTextureBinding>>();
			int num = 0;
			foreach (GameObject prefab in prefabs)
			{
				if ((Object)(object)prefab == (Object)null)
				{
					continue;
				}
				OptimizationTier optimizationTier = OptimizationTierResolver.Resolve(prefab);
				if (optimizationTier == OptimizationTier.None || optimizationTier == OptimizationTier.Excluded)
				{
					continue;
				}
				Renderer[] componentsInChildren = prefab.GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val in componentsInChildren)
				{
					if ((Object)(object)val == (Object)null || val is ParticleSystemRenderer)
					{
						continue;
					}
					Material[] sharedMaterials = val.sharedMaterials;
					if (sharedMaterials == null)
					{
						continue;
					}
					Material[] array = sharedMaterials;
					foreach (Material val2 in array)
					{
						if ((Object)(object)val2 == (Object)null)
						{
							continue;
						}
						num++;
						if (!val2.HasProperty("_MainTex"))
						{
							continue;
						}
						Texture texture = val2.GetTexture("_MainTex");
						Texture2D val3 = (Texture2D)(object)((texture is Texture2D) ? texture : null);
						if (!((Object)(object)val3 != (Object)null) || (((Texture)val3).width < value2 && ((Texture)val3).height < value2))
						{
							continue;
						}
						string text = ((Object)val3).name.ToLowerInvariant();
						if (!text.Contains("gui") && !text.Contains("hud") && !text.Contains("skybox"))
						{
							if (!dictionary.ContainsKey(val3))
							{
								dictionary[val3] = new List<MaterialTextureBinding>();
							}
							dictionary[val3].Add(new MaterialTextureBinding
							{
								Material = val2,
								PropertyName = "_MainTex"
							});
						}
					}
				}
			}
			Plugin.Log.LogInfo((object)$"[TextureOptimizer] Scan completed. Scanned materials: {num}. Unique textures qualifying: {dictionary.Count}.");
			int num2 = 0;
			int num3 = 0;
			string modVersion = "2.7.0";
			string version = Application.version;
			foreach (KeyValuePair<Texture2D, List<MaterialTextureBinding>> item in dictionary)
			{
				Texture2D key = item.Key;
				string cachePath = GetCachePath(((Object)key).name, value, modVersion, version);
				if (File.Exists(cachePath))
				{
					Texture2D val4 = LoadTextureFromCache(cachePath, ((Object)key).name);
					if ((Object)(object)val4 != (Object)null)
					{
						ApplyOptimizedTexture(item.Value, val4);
						num2++;
						continue;
					}
				}
				_processingQueue.Enqueue(new TextureProcessingWork
				{
					OriginalTexture = key,
					Targets = item.Value
				});
				num3++;
			}
			Plugin.Log.LogInfo((object)$"[TextureOptimizer] Applied from cache: {num2}. Queued for active processing: {num3}.");
			if (!_isProcessing && _processingQueue.Count > 0)
			{
				((MonoBehaviour)this).StartCoroutine(ProcessQueueCoroutine(value, modVersion, version));
			}
		}

		private IEnumerator ProcessQueueCoroutine(float downscaleMultiplier, string modVersion, string gameVersion)
		{
			_isProcessing = true;
			int processedCount = 0;
			while (_processingQueue.Count > 0)
			{
				TextureProcessingWork work = _processingQueue.Dequeue();
				if (!((Object)(object)work.OriginalTexture == (Object)null))
				{
					string texName = ((Object)work.OriginalTexture).name;
					int targetWidth = Mathf.Max(16, Mathf.RoundToInt((float)((Texture)work.OriginalTexture).width * downscaleMultiplier));
					int targetHeight = Mathf.Max(16, Mathf.RoundToInt((float)((Texture)work.OriginalTexture).height * downscaleMultiplier));
					Plugin.Log.LogInfo((object)$"[TextureOptimizer] Processing texture '{texName}' ({((Texture)work.OriginalTexture).width}x{((Texture)work.OriginalTexture).height} -> {targetWidth}x{targetHeight})...");
					RenderTexture rt = RenderTexture.GetTemporary(targetWidth, targetHeight, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)1);
					((Texture)rt).filterMode = (FilterMode)1;
					Graphics.Blit((Texture)(object)work.OriginalTexture, rt);
					yield return (object)new WaitForEndOfFrame();
					RenderTexture.active = rt;
					Texture2D val = new Texture2D(targetWidth, targetHeight, (TextureFormat)4, true, true);
					val.ReadPixels(new Rect(0f, 0f, (float)targetWidth, (float)targetHeight), 0, 0);
					val.Apply();
					RenderTexture.active = null;
					RenderTexture.ReleaseTemporary(rt);
					val.Compress(true);
					((Object)val).name = texName + "_VPO";
					_loadedTexturesCache[texName] = val;
					SaveTextureToCache(GetCachePath(texName, downscaleMultiplier, modVersion, gameVersion), val);
					ApplyOptimizedTexture(work.Targets, val);
					processedCount++;
					yield return null;
				}
			}
			Plugin.Log.LogInfo((object)$"[TextureOptimizer] Active processing queue finished. Transcoded {processedCount} new textures.");
			_isProcessing = false;
		}

		private static void ApplyOptimizedTexture(List<MaterialTextureBinding> targets, Texture2D optimizedTex)
		{
			foreach (MaterialTextureBinding target in targets)
			{
				if ((Object)(object)target.Material != (Object)null)
				{
					target.Material.SetTexture(target.PropertyName, (Texture)(object)optimizedTex);
				}
			}
		}

		private static string GetCachePath(string textureName, float scale, string modVersion, string gameVersion)
		{
			string text = Path.Combine(Paths.GameRootPath, "BepInEx", "cache", "VPO", "Textures");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			string arg = textureName.Replace("(Clone)", "").Trim();
			string text2 = $"{scale:F2}_{modVersion}_{gameVersion}";
			return Path.Combine(text, $"tex_{arg}_{text2.GetHashCode():X}.bin");
		}

		private static void SaveTextureToCache(string path, Texture2D tex)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected I4, but got Unknown
			try
			{
				byte[] rawTextureData = tex.GetRawTextureData();
				using (FileStream output = new FileStream(path, FileMode.Create, FileAccess.Write))
				{
					using BinaryWriter binaryWriter = new BinaryWriter(output);
					binaryWriter.Write("VPOTEX");
					binaryWriter.Write(((Texture)tex).width);
					binaryWriter.Write(((Texture)tex).height);
					binaryWriter.Write((int)tex.format);
					binaryWriter.Write(((Texture)tex).mipmapCount > 1);
					binaryWriter.Write(rawTextureData.Length);
					binaryWriter.Write(rawTextureData);
				}
				Plugin.Log.LogInfo((object)("[TextureOptimizer] Saved to cache: " + Path.GetFileName(path)));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[TextureOptimizer] Failed to save cache for " + ((Object)tex).name + ": " + ex.Message));
			}
		}

		private static Texture2D LoadTextureFromCache(string path, string originalName)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			if (_loadedTexturesCache.TryGetValue(originalName, out var value))
			{
				return value;
			}
			try
			{
				using FileStream input = new FileStream(path, FileMode.Open, FileAccess.Read);
				using BinaryReader binaryReader = new BinaryReader(input);
				if (binaryReader.ReadString() != "VPOTEX")
				{
					return null;
				}
				int num = binaryReader.ReadInt32();
				int num2 = binaryReader.ReadInt32();
				TextureFormat val = (TextureFormat)binaryReader.ReadInt32();
				bool flag = binaryReader.ReadBoolean();
				int count = binaryReader.ReadInt32();
				byte[] array = binaryReader.ReadBytes(count);
				Texture2D val2 = new Texture2D(num, num2, val, flag, true);
				((Object)val2).name = originalName + "_VPO";
				val2.LoadRawTextureData(array);
				val2.Apply(false, true);
				_loadedTexturesCache[originalName] = val2;
				Plugin.Log.LogInfo((object)$"[TextureOptimizer] Loaded from cache: {originalName} ({num}x{num2})");
				return val2;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[TextureOptimizer] Failed to load cache for " + originalName + ": " + ex.Message));
				return null;
			}
		}

		private void OnDestroy()
		{
			_processingQueue.Clear();
			_loadedTexturesCache.Clear();
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}
	}
	[HarmonyPatch]
	public static class TexturePatches
	{
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void OnZNetSceneAwake(ZNetScene __instance)
		{
			if (Plugin.TextureOptimizationEnabled.Value)
			{
				TextureOptimizer.OptimizeSceneTextures(__instance.m_prefabs);
			}
		}
	}
}
namespace ValheimPerformanceOverhaul.Core
{
	[Serializable]
	public class SerializableMesh
	{
		public string Name;

		public Vector3[] Vertices;

		public Vector3[] Normals;

		public Vector2[] UV;

		public Vector4[] Tangents;

		public int[][] SubMeshTriangles;

		public SerializableMesh()
		{
		}

		public SerializableMesh(Mesh mesh)
		{
			Name = ((Object)mesh).name;
			Vertices = mesh.vertices;
			Normals = mesh.normals;
			UV = mesh.uv;
			Tangents = mesh.tangents;
			SubMeshTriangles = new int[mesh.subMeshCount][];
			for (int i = 0; i < mesh.subMeshCount; i++)
			{
				SubMeshTriangles[i] = mesh.GetTriangles(i);
			}
		}

		public Mesh ToMesh()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			Mesh val = new Mesh();
			((Object)val).name = Name;
			val.vertices = Vertices;
			if (Normals != null && Normals.Length != 0)
			{
				val.normals = Normals;
			}
			if (UV != null && UV.Length != 0)
			{
				val.uv = UV;
			}
			if (Tangents != null && Tangents.Length != 0)
			{
				val.tangents = Tangents;
			}
			val.subMeshCount = SubMeshTriangles.Length;
			for (int i = 0; i < SubMeshTriangles.Length; i++)
			{
				val.SetTriangles(SubMeshTriangles[i], i);
			}
			val.RecalculateBounds();
			return val;
		}
	}
	public static class AssetCache
	{
		private static readonly string CacheDirectory = Path.Combine(Paths.GameRootPath, "BepInEx", "cache", "VPO");

		public static string GetCacheFilePath(string prefabName, string modVersion, string gameVersion)
		{
			string text = prefabName.Replace("(Clone)", "").Trim();
			return Path.Combine(CacheDirectory, "LOD_v3_" + text + "_" + modVersion + "_" + gameVersion + ".bin");
		}

		public static void SaveLODsToCache(string prefabName, string modVersion, string gameVersion, DecimationResult result)
		{
			string cacheFilePath = GetCacheFilePath(prefabName, modVersion, gameVersion);
			try
			{
				string directoryName = Path.GetDirectoryName(cacheFilePath);
				if (!Directory.Exists(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				using FileStream output = new FileStream(cacheFilePath, FileMode.Create, FileAccess.Write);
				using BinaryWriter binaryWriter = new BinaryWriter(output);
				binaryWriter.Write("VPOLOD");
				binaryWriter.Write(result.DecimatedData.Count);
				for (int i = 0; i < result.DecimatedData.Count; i++)
				{
					DecimatedRendererData decimatedRendererData = result.DecimatedData[i];
					binaryWriter.Write(decimatedRendererData.OriginalData.RelativePath);
					WriteMesh(binaryWriter, decimatedRendererData.LOD1Mesh);
					WriteMesh(binaryWriter, decimatedRendererData.LOD2Mesh);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[AssetCache] Failed to save LOD cache for " + prefabName + ": " + ex.Message));
			}
		}

		public static DecimationResult LoadLODsFromCache(string prefabName, string modVersion, string gameVersion, List<RendererMeshData> originalData)
		{
			string cacheFilePath = GetCacheFilePath(prefabName, modVersion, gameVersion);
			if (!File.Exists(cacheFilePath))
			{
				return null;
			}
			try
			{
				using FileStream input = new FileStream(cacheFilePath, FileMode.Open, FileAccess.Read);
				using BinaryReader binaryReader = new BinaryReader(input);
				if (binaryReader.ReadString() != "VPOLOD")
				{
					return null;
				}
				int num = binaryReader.ReadInt32();
				DecimationResult decimationResult = new DecimationResult
				{
					DecimatedData = new List<DecimatedRendererData>()
				};
				for (int i = 0; i < num; i++)
				{
					string relPath = binaryReader.ReadString();
					SerializableMesh lOD1Mesh = ReadMesh(binaryReader);
					SerializableMesh lOD2Mesh = ReadMesh(binaryReader);
					RendererMeshData rendererMeshData = originalData.Find((RendererMeshData d) => d.RelativePath == relPath);
					if (rendererMeshData != null)
					{
						decimationResult.DecimatedData.Add(new DecimatedRendererData
						{
							OriginalData = rendererMeshData,
							LOD1Mesh = lOD1Mesh,
							LOD2Mesh = lOD2Mesh
						});
					}
				}
				return decimationResult;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[AssetCache] Failed to load LOD cache for " + prefabName + ": " + ex.Message));
				return null;
			}
		}

		private static void WriteMesh(BinaryWriter writer, SerializableMesh sMesh)
		{
			writer.Write(sMesh.Name ?? "Mesh");
			writer.Write(sMesh.Vertices.Length);
			for (int i = 0; i < sMesh.Vertices.Length; i++)
			{
				writer.Write(sMesh.Vertices[i].x);
				writer.Write(sMesh.Vertices[i].y);
				writer.Write(sMesh.Vertices[i].z);
			}
			int num = ((sMesh.Normals != null) ? sMesh.Normals.Length : 0);
			writer.Write(num);
			for (int j = 0; j < num; j++)
			{
				writer.Write(sMesh.Normals[j].x);
				writer.Write(sMesh.Normals[j].y);
				writer.Write(sMesh.Normals[j].z);
			}
			int num2 = ((sMesh.UV != null) ? sMesh.UV.Length : 0);
			writer.Write(num2);
			for (int k = 0; k < num2; k++)
			{
				writer.Write(sMesh.UV[k].x);
				writer.Write(sMesh.UV[k].y);
			}
			int num3 = ((sMesh.Tangents != null) ? sMesh.Tangents.Length : 0);
			writer.Write(num3);
			for (int l = 0; l < num3; l++)
			{
				writer.Write(sMesh.Tangents[l].x);
				writer.Write(sMesh.Tangents[l].y);
				writer.Write(sMesh.Tangents[l].z);
				writer.Write(sMesh.Tangents[l].w);
			}
			writer.Write(sMesh.SubMeshTriangles.Length);
			for (int m = 0; m < sMesh.SubMeshTriangles.Length; m++)
			{
				int[] array = sMesh.SubMeshTriangles[m];
				writer.Write(array.Length);
				for (int n = 0; n < array.Length; n++)
				{
					writer.Write(array[n]);
				}
			}
		}

		private static SerializableMesh ReadMesh(BinaryReader reader)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			SerializableMesh serializableMesh = new SerializableMesh();
			serializableMesh.Name = reader.ReadString();
			int num = reader.ReadInt32();
			serializableMesh.Vertices = (Vector3[])(object)new Vector3[num];
			for (int i = 0; i < num; i++)
			{
				serializableMesh.Vertices[i] = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
			}
			int num2 = reader.ReadInt32();
			if (num2 > 0)
			{
				serializableMesh.Normals = (Vector3[])(object)new Vector3[num2];
				for (int j = 0; j < num2; j++)
				{
					serializableMesh.Normals[j] = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
				}
			}
			int num3 = reader.ReadInt32();
			if (num3 > 0)
			{
				serializableMesh.UV = (Vector2[])(object)new Vector2[num3];
				for (int k = 0; k < num3; k++)
				{
					serializableMesh.UV[k] = new Vector2(reader.ReadSingle(), reader.ReadSingle());
				}
			}
			int num4 = reader.ReadInt32();
			if (num4 > 0)
			{
				serializableMesh.Tangents = (Vector4[])(object)new Vector4[num4];
				for (int l = 0; l < num4; l++)
				{
					serializableMesh.Tangents[l] = new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
				}
			}
			int num5 = reader.ReadInt32();
			serializableMesh.SubMeshTriangles = new int[num5][];
			for (int m = 0; m < num5; m++)
			{
				int num6 = reader.ReadInt32();
				serializableMesh.SubMeshTriangles[m] = new int[num6];
				for (int n = 0; n < num6; n++)
				{
					serializableMesh.SubMeshTriangles[m][n] = reader.ReadInt32();
				}
			}
			return serializableMesh;
		}
	}
	[HarmonyPatch]
	public static class RigidbodyDebugPatches
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static bool Prefix_SetVelocity(Rigidbody __instance, Vector3 value)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || !__instance.isKinematic || value == Vector3.zero)
			{
				return true;
			}
			if (Plugin.DebugLoggingEnabled.Value)
			{
				Plugin.Log.LogWarning((object)($"[RigidbodyDebug] Attempted to set velocity {value} on KINEMATIC " + "Rigidbody " + ((Object)__instance).name + ". StackTrace:\n" + Environment.StackTrace));
			}
			return true;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static bool Prefix_SetAngularVelocity(Rigidbody __instance, Vector3 value)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || !__instance.isKinematic || value == Vector3.zero)
			{
				return true;
			}
			if (Plugin.DebugLoggingEnabled.Value)
			{
				Plugin.Log.LogWarning((object)($"[RigidbodyDebug] Attempted to set angularVelocity {value} on KINEMATIC " + "Rigidbody " + ((Object)__instance).name + ". StackTrace:\n" + Environment.StackTrace));
			}
			return true;
		}

		[HarmonyPatch(typeof(Debug), "LogWarning", new Type[] { typeof(object) })]
		[HarmonyPrefix]
		private static void Prefix_CatchUnityWarning(object message)
		{
			if (message != null && Plugin.DebugLoggingEnabled.Value)
			{
				string text = message.ToString();
				if (text.Contains("linear velocity") && text.Contains("kinematic"))
				{
					Plugin.Log.LogWarning((object)("[RigidbodyDebug] CAUGHT UNITY WARNING: " + text + "\nSTACKTRACE:\n" + Environment.StackTrace));
				}
			}
		}
	}
	[HarmonyPatch]
	[HarmonyPatch]
	public static class RigidbodyLinearVelocityDebugPatch
	{
		[HarmonyPrepare]
		public static bool Prepare()
		{
			return typeof(Rigidbody).GetProperty("linearVelocity", BindingFlags.Instance | BindingFlags.Public) != null;
		}

		[HarmonyTargetMethod]
		public static MethodBase TargetMethod()
		{
			return typeof(Rigidbody).GetProperty("linearVelocity", BindingFlags.Instance | BindingFlags.Public)?.GetSetMethod();
		}

		[HarmonyPrefix]
		private static bool Prefix_SetLinearVelocity(Rigidbody __instance, Vector3 value)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || !__instance.isKinematic || value == Vector3.zero)
			{
				return true;
			}
			if (Plugin.DebugLoggingEnabled.Value)
			{
				Plugin.Log.LogWarning((object)($"[RigidbodyDebug] Attempted to set linearVelocity {value} on KINEMATIC " + "Rigidbody " + ((Object)__instance).name + ". StackTrace:\n" + Environment.StackTrace));
			}
			return true;
		}
	}
	public class FrameBudgetGuard : MonoBehaviour
	{
		private const int SAMPLE_CAPACITY = 120;

		private readonly Queue<float> _frametimeQueue = new Queue<float>(120);

		private readonly List<float> _sortBuffer = new List<float>(120);

		private float _current1PctLowMs;

		private float _averageFrameMs;

		private float _checkTimer;

		private const float CHECK_INTERVAL = 0.5f;

		private bool _isThrottling;

		private static readonly Comparison<float> _descendingComparison = (float a, float b) => b.CompareTo(a);

		public static FrameBudgetGuard Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		private void Update()
		{
			if (Plugin.FrameBudgetGuardEnabled.Value)
			{
				float item = Time.unscaledDeltaTime * 1000f;
				if (_frametimeQueue.Count >= 120)
				{
					_frametimeQueue.Dequeue();
				}
				_frametimeQueue.Enqueue(item);
				_checkTimer += Time.unscaledDeltaTime;
				if (!(_checkTimer < 0.5f))
				{
					_checkTimer = 0f;
					CalculateMetrics();
					ApplyFrameBudget(_current1PctLowMs);
					ApplyInputLagThrottling();
				}
			}
		}

		private void CalculateMetrics()
		{
			if (_frametimeQueue.Count == 0)
			{
				return;
			}
			_sortBuffer.Clear();
			float num = 0f;
			foreach (float item in _frametimeQueue)
			{
				_sortBuffer.Add(item);
				num += item;
			}
			_averageFrameMs = num / (float)_frametimeQueue.Count;
			_sortBuffer.Sort(_descendingComparison);
			int num2 = Mathf.Max(1, _sortBuffer.Count / 100);
			float num3 = 0f;
			for (int i = 0; i < num2; i++)
			{
				num3 += _sortBuffer[i];
			}
			_current1PctLowMs = num3 / (float)num2;
		}

		private void ApplyInputLagThrottling()
		{
			if (_current1PctLowMs > _averageFrameMs * 1.4f)
			{
				if (QualitySettings.maxQueuedFrames != 2)
				{
					QualitySettings.maxQueuedFrames = 2;
				}
			}
			else if (QualitySettings.maxQueuedFrames != 3)
			{
				QualitySettings.maxQueuedFrames = 3;
			}
		}

		private void ApplyFrameBudget(float worstMs)
		{
			float value = Plugin.FrameBudgetThresholdMs.Value;
			float value2 = Plugin.FrameBudgetThrottledDelta.Value;
			float value3 = Plugin.FrameBudgetNormalDelta.Value;
			if (worstMs > value && !_isThrottling)
			{
				Time.maximumDeltaTime = value2;
				_isThrottling = true;
			}
			else if (worstMs <= value && _isThrottling)
			{
				Time.maximumDeltaTime = value3;
				_isThrottling = false;
			}
		}

		private void OnDestroy()
		{
			Time.maximumDeltaTime = 0.3333f;
			QualitySettings.maxQueuedFrames = 3;
			Instance = null;
		}
	}
	[HarmonyPatch(typeof(GC), "Collect", new Type[] { })]
	public static class GCCollectPatch
	{
		[HarmonyPriority(600)]
		[HarmonyPrefix]
		private static bool PreventGCWhenPlayerIsBusy()
		{
			if (!Plugin.GcControlEnabled.Value)
			{
				return true;
			}
			return !GCPatches.IsPlayerBusyProxy();
		}
	}
	public enum HardwareClass
	{
		Weak,
		Medium,
		Strong
	}
	public static class HardwareProfiler
	{
		public static HardwareClass CurrentClass { get; private set; }

		public static float AIFarInterval { get; private set; }

		public static float ShadowDistance { get; private set; }

		public static void Initialize()
		{
			int processorCount = SystemInfo.processorCount;
			int graphicsMemorySize = SystemInfo.graphicsMemorySize;
			int systemMemorySize = SystemInfo.systemMemorySize;
			if (processorCount < 6 || graphicsMemorySize < 4096)
			{
				CurrentClass = HardwareClass.Weak;
				AIFarInterval = 2f;
				ShadowDistance = 20f;
			}
			else if (processorCount <= 8 || graphicsMemorySize <= 8192)
			{
				CurrentClass = HardwareClass.Medium;
				AIFarInterval = 1f;
				ShadowDistance = 40f;
			}
			else
			{
				CurrentClass = HardwareClass.Strong;
				AIFarInterval = 0.5f;
				ShadowDistance = 60f;
			}
			Plugin.Log.LogInfo((object)$"[HardwareProfiler] CPU Cores: {processorCount}, VRAM: {graphicsMemorySize}MB, RAM: {systemMemorySize}MB -> Profile: {CurrentClass}");
		}
	}
	public enum OptimizationTier
	{
		None,
		Instancing,
		Combining,
		StaticBatching,
		Excluded
	}
	public static class OptimizationTierResolver
	{
		private static readonly HashSet<string> _manualExclusions = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		public static void Initialize()
		{
			_manualExclusions.Clear();
			string text = Plugin.CullerExclusions?.Value ?? "";
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			string[] array = text.Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (!string.IsNullOrEmpty(text2))
				{
					_manualExclusions.Add(text2);
				}
			}
		}

		public static OptimizationTier Resolve(GameObject prefab)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return OptimizationTier.None;
			}
			string text = ((Object)prefab).name.Replace("(Clone)", "").Trim();
			if (_manualExclusions.Contains(text))
			{
				return OptimizationTier.Excluded;
			}
			if ((Object)(object)prefab.GetComponentInChildren<Rigidbody>() != (Object)null && (Object)(object)prefab.GetComponentInParent<ZSyncTransform>() != (Object)null)
			{
				return OptimizationTier.Excluded;
			}
			if ((Object)(object)prefab.GetComponent<Character>() != (Object)null)
			{
				return OptimizationTier.None;
			}
			if (IsInstancingTarget(text, prefab))
			{
				return OptimizationTier.Instancing;
			}
			if (IsCombiningTarget(text, prefab))
			{
				return OptimizationTier.Combining;
			}
			if (IsStaticBatchTarget(text, prefab))
			{
				return OptimizationTier.StaticBatching;
			}
			return OptimizationTier.None;
		}

		private static bool IsInstancingTarget(string name, GameObject prefab)
		{
			string text = name.ToLowerInvariant();
			if (text.Contains("grass") || text.Contains("clutter") || text.Contains("flower") || text.Contains("mushroom") || text.Contains("dandelion") || text.Contains("shrub") || text.Contains("bush") || text.Contains("heather") || text.Contains("vfx"))
			{
				return true;
			}
			if (text.Contains("stump") || text.Contains("log") || text.Contains("stub"))
			{
				return true;
			}
			if (text.Contains("rock") || text.Contains("stone") || text.Contains("boulder") || text.Contains("cliff") || text.Contains("ore") || text.Contains("deposit") || text.Contains("copper") || text.Contains("tin") || text.Contains("silver"))
			{
				return true;
			}
			return false;
		}

		private static bool IsCombiningTarget(string name, GameObject prefab)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			Piece component = prefab.GetComponent<Piece>();
			if ((Object)(object)component != (Object)null && ((int)component.m_category == 0 || (int)component.m_category == 4))
			{
				return true;
			}
			return false;
		}

		private static bool IsStaticBatchTarget(string name, GameObject prefab)
		{
			if ((Object)(object)prefab.GetComponent<Character>() != (Object)null || (Object)(object)prefab.GetComponent<BaseAI>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)prefab.GetComponentInChildren<Rigidbody>() != (Object)null || (Object)(object)prefab.GetComponent<ZSyncTransform>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)prefab.GetComponent<WearNTear>() != (Object)null || (Object)(object)prefab.GetComponent<Destructible>() != (Object)null || (Object)(object)prefab.GetComponent<MineRock>() != (Object)null || (Object)(object)prefab.GetComponent<MineRock5>() != (Object)null || (Object)(object)prefab.GetComponent<TreeBase>() != (Object)null || (Object)(object)prefab.GetComponent<TreeLog>() != (Object)null)
			{
				return false;
			}
			if ((Object)(object)prefab.GetComponentInChildren<MeshRenderer>(true) == (Object)null)
			{
				return false;
			}
			if (IsInstancingTarget(name, prefab) || IsCombiningTarget(name, prefab))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	public static class SceneLoaderPatch
	{
		[HarmonyPatch(typeof(SceneLoader), "Start")]
		[HarmonyPrefix]
		private static void SceneLoader_Start_Prefix(SceneLoader __instance)
		{
			if (Plugin.SkipIntroEnabled.Value)
			{
				Traverse.Create((object)__instance).Field("_showLogos").SetValue((object)false);
				if (Plugin.DebugLoggingEnabled.Value)
				{
					Plugin.Log.LogInfo((object)"[SceneLoader] Intro logos skipped.");
				}
			}
		}
	}
}
namespace ValheimPerformanceOverhaul.AI
{
	public class AIOptimizerManager : MonoBehaviour
	{
		private readonly List<AIOptimizer> _optimizers = new List<AIOptimizer>(1024);

		private readonly HashSet<AIOptimizer> _optimizerSet = new HashSet<AIOptimizer>();

		public static AIOptimizerManager Instance { get; private set; }

		public static void Initialize()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("_VPO_AIOptimizerManager");
				Object.DontDestroyOnLoad((Object)val);
				val.AddComponent<AIOptimizerManager>();
			}
		}

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else
			{
				Instance = this;
			}
		}

		public void Register(AIOptimizer optimizer)
		{
			if (!((Object)(object)optimizer == (Object)null) && _optimizerSet.Add(optimizer))
			{
				_optimizers.Add(optimizer);
			}
		}

		public void Unregister(AIOptimizer optimizer)
		{
			if (!((Object)(object)optimizer == (Object)null) && _optimizerSet.Remove(optimizer))
			{
				int num = _optimizers.IndexOf(optimizer);
				if (num >= 0)
				{
					int index = _optimizers.Count - 1;
					_optimizers[num] = _optimizers[index];
					_optimizers.RemoveAt(index);
				}
			}
		}

		private void FixedUpdate()
		{
			if (!Plugin.AiThrottlingEnabled.Value)
			{
				return;
			}
			for (int num = _optimizers.Count - 1; num >= 0; num--)
			{
				AIOptimizer aIOptimizer = _optimizers[num];
				if (aIOptimizer == null || (Object)(object)aIOptimizer == (Object)null)
				{
					_optimizerSet.Remove(aIOptimizer);
					_optimizers.RemoveAt(num);
				}
				else
				{
					aIOptimizer.DoOptimizeTick();
				}
			}
		}

		private void OnDestroy()
		{
			_optimizers.Clear();
			_optimizerSet.Clear();
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}
	}
	[HarmonyPatch]
	public static class PathfindingScheduler
	{
		private static int _requestsThisFrame;

		private static int _lastFrameCount = -1;

		private const float NEAR_DISTANCE = 60f;

		private const int BASE_BUDGET = 5;

		private static int _maxRequestsPerFrame = 5;

		public static void ApplyHardwareBudget()
		{
			switch (HardwareProfiler.CurrentClass)
			{
			case HardwareClass.Weak:
				_maxRequestsPerFrame = 3;
				break;
			case HardwareClass.Medium:
				_maxRequestsPerFrame = 5;
				break;
			case HardwareClass.Strong:
				_maxRequestsPerFrame = 8;
				break;
			default:
				_maxRequestsPerFrame = 5;
				break;
			}
			Plugin.Log.LogInfo((object)$"[PathfindingScheduler] Budget set to {_maxRequestsPerFrame}/frame ({HardwareProfiler.CurrentClass}).");
		}

		[HarmonyTargetMethod]
		private static MethodBase TargetMethod()
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(BaseAI), "FindPath", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				Plugin.Log.LogInfo((object)"[PathfindingScheduler] Targeting BaseAI.FindPath.");
				return methodInfo;
			}
			Plugin.Log.LogWarning((object)"[PathfindingScheduler] BaseAI.FindPath not found — patch disabled.");
			return null;
		}

		[HarmonyPrefix]
		private static bool Prefix(BaseAI __instance)
		{
			if (!Plugin.AiThrottlingEnabled.Value)
			{
				return true;
			}
			Character component = ((Component)__instance).GetComponent<Character>();
			if ((Object)(object)component != (Object)null && component.IsPlayer())
			{
				return true;
			}
			AIOptimizer component2 = ((Component)__instance).GetComponent<AIOptimizer>();
			if ((Object)(object)component2 == (Object)null)
			{
				return true;
			}
			if (component2.GetDistanceToPlayer() <= 60f)
			{
				return true;
			}
			int frameCount = Time.frameCount;
			if (frameCount != _lastFrameCount)
			{
				_lastFrameCount = frameCount;
				_requestsThisFrame = 0;
			}
			if (_requestsThisFrame < _maxRequestsPerFrame)
			{
				_requestsThisFrame++;
				return true;
			}
			return false;
		}
	}
	public class AIOptimizer : MonoBehaviour
	{
		private BaseAI _ai;

		private ZNetView _nview;

		private Character _character;

		private float _distCheckTimer;

		private const float DIST_CHECK_INTERVAL = 1f;

		private float _closestPlayerDistSqr = 1000000f;

		private Character _cachedEnemy;

		private float _lastEnemyCheck;

		private float _lastAttackCheck;

		private float _lastPathUpdate;

		private Vector3 _lastPathTargetPos;

		private readonly Dictionary<int, (bool visible, float time)> _losCache = new Dictionary<int, (bool, float)>();

		private const int MAX_LOS_CACHE_SIZE = 100;

		private const float LOS_CACHE_TIMEOUT = 10f;

		private float _losCleanupTimer;

		private void Awake()
		{
			_ai = ((Component)this).GetComponent<BaseAI>();
			_nview = ((Component)this).GetComponent<ZNetView>();
			_character = ((Component)this).GetComponent<Character>();
		}

		private void OnEnable()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			_closestPlayerDistSqr = 0f;
			_distCheckTimer = 1f;
			_cachedEnemy = null;
			_lastEnemyCheck = -100f;
			_lastAttackCheck = -100f;
			_lastPathUpdate = -100f;
			_lastPathTargetPos = Vector3.zero;
			_losCache.Clear();
			_losCleanupTimer = 0f;
			AIOptimizerManager.Instance?.Register(this);
		}

		private void OnDisable()
		{
			AIOptimizerManager.Instance?.Unregister(this);
		}

		public float GetDistanceToPlayer()
		{
			return Mathf.Sqrt(_closestPlayerDistSqr);
		}

		public void DoOptimizeTick()
		{
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid() || !_nview.IsOwner())
			{
				return;
			}
			_distCheckTimer += Time.fixedDeltaTime;
			if (!(_distCheckTimer < 1f))
			{
				_distCheckTimer = 0f;
				UpdateClosestPlayerDistance();
				_losCleanupTimer += 1f;
				if (_losCleanupTimer >= 10f)
				{
					_losCleanupTimer = 0f;
					CleanupLOSCache();
				}
			}
		}

		private void UpdateClosestPlayerDistance()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			_closestPlayerDistSqr = 1000000f;
			Vector3 val;
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				val = ((Component)Player.m_localPlayer).transform.position - ((Component)this).transform.position;
				_closestPlayerDistSqr = ((Vector3)(ref val)).sqrMagnitude;
			}
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if (!((Object)(object)allPlayer == (Object)null))
				{
					val = ((Component)allPlayer).transform.position - ((Component)this).transform.position;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					if (sqrMagnitude < _closestPlayerDistSqr)
					{
						_closestPlayerDistSqr = sqrMagnitude;
					}
				}
			}
		}

		public bool ShouldCheckEnemy(out Character currentEnemy)
		{
			currentEnemy = _cachedEnemy;
			float time = Time.time;
			float interval = GetInterval(0.5f, 2f);
			if (time - _lastEnemyCheck >= interval)
			{
				_lastEnemyCheck = time;
				return true;
			}
			return false;
		}

		public void UpdateCachedEnemy(Character enemy)
		{
			_cachedEnemy = enemy;
		}

		public bool ShouldCheckAttack()
		{
			float time = Time.time;
			float interval = GetInterval(0.3f, 1f);
			if (time - _lastAttackCheck >= interval)
			{
				_lastAttackCheck = time;
				return true;
			}
			return false;
		}

		public bool ShouldUpdatePath(Vector3 targetPos)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			float time = Time.time;
			float interval = GetInterval(0.5f, 2f);
			bool num = time - _lastPathUpdate >= interval;
			float value = Plugin.PathCacheDistance.Value;
			Vector3 val = targetPos - _lastPathTargetPos;
			bool flag = ((Vector3)(ref val)).sqrMagnitude >= value * value;
			if (num || flag)
			{
				_lastPathUpdate = time;
				_lastPathTargetPos = targetPos;
				return true;
			}
			return false;
		}

		public bool GetCachedLOS(Character target, out bool visible)
		{
			visible = false;
			if ((Object)(object)target == (Object)null)
			{
				return false;
			}
			int instanceID = ((Object)target).GetInstanceID();
			float time = Time.time;
			if (_losCache.TryGetValue(instanceID, out (bool, float) value) && time - value.Item2 < 0.5f)
			{
				(visible, _) = value;
				return true;
			}
			return false;
		}

		public void SetCachedLOS(Character target, bool visible)
		{
			if (!((Object)(object)target == (Object)null))
			{
				int instanceID = ((Object)target).GetInstanceID();
				_losCache[instanceID] = (visible, Time.time);
				if (_losCache.Count > 100)
				{
					CleanupLOSCache();
				}
			}
		}

		private float GetInterval(float min, float max)
		{
			if (_closestPlayerDistSqr < 1600f)
			{
				return min;
			}
			if (_closestPlayerDistSqr > 14400f)
			{
				return max;
			}
			float num = (_closestPlayerDistSqr - 1600f) / 12800f;
			return Mathf.Lerp(min, max, num);
		}

		private void CleanupLOSCache()
		{
			float time = Time.time;
			List<int> list = new List<int>();
			foreach (KeyValuePair<int, (bool, float)> item in _losCache)
			{
				if (time - item.Value.Item2 > 10f)
				{
					list.Add(item.Key);
				}
			}
			foreach (int item2 in list)
			{
				_losCache.Remove(item2);
			}
		}

		private void OnDestroy()
		{
			_losCache.Clear();
		}
	}
	[HarmonyPatch]
	public static class AIPatches
	{
		private const float AI_ACTIVATION_RADIUS = 60f;

		private const float AI_SLOW_UPDATE_INTERVAL = 5f;

		private static readonly Dictionary<BaseAI, float> _lastSlowUpdate = new Dictionary<BaseAI, float>();

		[HarmonyPatch(typeof(Character), "CustomFixedUpdate")]
		[HarmonyPriority(600)]
		[HarmonyPrefix]
		private static bool CustomFixedUpdate_Prefix(Character __instance)
		{
			if (!Plugin.AiThrottlingEnabled.Value)
			{
				return true;
			}
			if (__instance.IsPlayer())
			{
				return true;
			}
			AIOptimizer component = ((Component)__instance).GetComponent<AIOptimizer>();
			if ((Object)(object)component != (Object)null && component.GetDistanceToPlayer() > 60f)
			{
				return (Time.frameCount + ((Object)__instance).GetInstanceID()) % 2 == 0;
			}
			return true;
		}

		[HarmonyPatch(typeof(BaseAI), "Awake")]
		[HarmonyPostfix]
		private static void BaseAI_Awake_Postfix(BaseAI __instance)
		{
			if ((Object)(object)((Component)__instance).GetComponent<AIOptimizer>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<AIOptimizer>();
			}
			Character component = ((Component)__instance).GetComponent<Character>();
			if ((Object)(object)component != (Object)null && component.IsTamed() && (Object)(object)((Component)__instance).GetComponent<TamedIdleOptimizer>() == (Object)null)
			{
				((Component)__instance).gameObject.AddComponent<TamedIdleOptimizer>();
			}
			_lastSlowUpdate[__instance] = Time.time - 5f;
		}

		[HarmonyPatch(typeof(MonsterAI), "UpdateAI")]
		[HarmonyPrefix]
		private static bool MonsterAI_UpdateAI_Prefix(MonsterAI __instance)
		{
			if (!Plugin.AiThrottlingEnabled.Value)
			{
				return true;
			}
			if ((Object)(object)ZNet.instance != (Object)null && !ZNet.instance.IsServer())
			{
				return true;
			}
			AIOptimizer component = ((Component)__instance).GetComponent<AIOptimizer>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			float distanceToPlayer = component.GetDistanceToPlayer();
			if (distanceToPlayer <= 60f)
			{
				return true;
			}
			if (!_lastSlowUpdate.TryGetValue((BaseAI)(object)__instance, out var value))
			{
				_lastSlowUpdate[(BaseAI)(object)__instance] = Time.time;
				return false;
			}
			if (Time.time - value < 5f)
			{
				return false;
			}
			_lastSlowUpdate[(BaseAI)(object)__instance] = Time.time;
			if (Plugin.DebugLoggingEnabled.Value && Time.frameCount % 300 == 0)
			{
				Plugin.Log.LogInfo((object)$"[AI] Slow update for {((Object)__instance).name} at {distanceToPlayer:F1}m");
			}
			return true;
		}

		[HarmonyPatch(typeof(BaseAI), "OnDestroy")]
		[HarmonyPostfix]
		private static void BaseAI_OnDestroy_Postfix(BaseAI __instance)
		{
			_lastSlowUpdate.Remove(__instance);
		}

		[HarmonyPatch(typeof(BaseAI), "FindEnemy")]
		[HarmonyPrefix]
		private static bool FindEnemy_Prefix(BaseAI __instance, ref Character __result)
		{
			if (!Plugin.AiThrottlingEnabled.Value)
			{
				return true;
			}
			AIOptimizer component = ((Component)__instance).GetComponent<AIOptimizer>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			if (component.GetDistanceToPlayer() < 60f)
			{
				return true;
			}
			if (!component.ShouldCheckEnemy(out __result))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(BaseAI), "FindEnemy")]
		[HarmonyPostfix]
		private static void FindEnemy_Postfix(BaseAI __instance, Character __result)
		{
			if (Plugin.AiThrottlingEnabled.Value)
			{
				((Component)__instance).GetComponent<AIOptimizer>()?.UpdateCachedEnemy(__result);
			}
		}

		[HarmonyPatch(typeof(BaseAI), "CanSeeTarget", new Type[] { typeof(Character) })]
		[HarmonyPrefix]
		private static bool CanSeeTarget_Prefix(BaseAI __instance, Character target, ref bool __result)
		{
			if (!Plugin.AiThrottlingEnabled.Value)
			{
				return true;
			}
			AIOptimizer component = ((Component)__instance).GetComponent<AIOptimizer>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			if (component.GetDistanceToPlayer() < 60f)
			{
				return true;
			}
			if (component.GetCachedLOS(target, out var visible))
			{
				__result = visible;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(BaseAI), "CanSeeTarget", new Type[] { typeof(Character) })]
		[HarmonyPostfix]
		private static void CanSeeTarget_Postfix(BaseAI __instance, Character target, bool __result)
		{
			if (Plugin.AiThrottlingEnabled.Value && !((Object)(object)target == (Object)null))
			{
				((Component)__instance).GetComponent<AIOptimizer>()?.SetCachedLOS(target, __result);
			}
		}

		[HarmonyPatch(typeof(MonsterAI), "DoAttack")]
		[HarmonyPrefix]
		private static bool DoAttack_Prefix(MonsterAI __instance)
		{
			if (!Plugin.AiThrottlingEnabled.Value)
			{
				return true;
			}
			AIOptimizer component = ((Component)__instance).GetComponent<AIOptimizer>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			if (component.GetDistanceToPlayer() < 60f)
			{
				return true;
			}
			return component.ShouldCheckAttack();
		}

		[HarmonyPatch(typeof(ZNet), "Update")]
		[HarmonyPostfix]
		private static void CleanupSlowUpdateCache()
		{
			if (!Plugin.AiThrottlingEnabled.Value || Time.frameCount % 3600 != 0)
			{
				return;
			}
			List<BaseAI> list = new List<BaseAI>();
			float time = Time.time;
			foreach (KeyValuePair<BaseAI, float> item in _lastSlowUpdate)
			{
				if ((Object)(object)item.Key == (Object)null || time - item.Value > 60f)
				{
					list.Add(item.Key);
				}
			}
			foreach (BaseAI item2 in list)
			{
				_lastSlowUpdate.Remove(item2);
			}
			if (Plugin.DebugLoggingEnabled.Value && list.Count > 0)
			{
				Plugin.Log.LogInfo((object)$"[AI] Cleaned {list.Count} stale slow-update entries");
			}
		}
	}
	public class TamedIdleOptimizer : MonoBehaviour
	{
		private Character _character;

		private BaseAI _baseAI;

		private MonsterAI _monsterAI;

		private ZNetView _nview;

		private Animator _animator;

		private Rigidbody _rigidbody;

		private Collider[] _colliders;

		private bool _isInIdleMode;

		private float _lastStateChange;

		private float _lastCombatTime;

		private float _lastCheckTime;

		private bool _originalAIEnabled = true;

		private float _originalAnimatorSpeed = 1f;

		private bool _originalRigidbodyKinematic;

		private bool[] _originalColliderStates;

		private bool _cachedInsideBase;

		private float _lastBaseCheckTime = -999f;

		private const float BASE_RECHECK_INTERVAL = 5f;

		private static readonly int _pieceMask = LayerMask.GetMask(new string[2] { "piece", "piece_nonsolid" });

		private const float CHECK_INTERVAL = 1f;

		private const float STATE_CHANGE_COOLDOWN = 2f;

		private const float PLAYER_INTERACT_DIST_SQR = 25f;

		private void Awake()
		{
			_character = ((Component)this).GetComponent<Character>();
			_baseAI = ((Component)this).GetComponent<BaseAI>();
			_monsterAI = ((Component)this).GetComponent<MonsterAI>();
			_nview = ((Component)this).GetComponent<ZNetView>();
			_animator = ((Component)this).GetComponentInChildren<Animator>();
			_rigidbody = ((Component)this).GetComponent<Rigidbody>();
			_colliders = ((Component)this).GetComponentsInChildren<Collider>(true);
			if ((Object)(object)_animator != (Object)null)
			{
				_originalAnimatorSpeed = _animator.speed;
			}
			if ((Object)(object)_rigidbody != (Object)null)
			{
				_originalRigidbodyKinematic = _rigidbody.isKinematic;
			}
			if (_colliders != null && _colliders.Length != 0)
			{
				_originalColliderStates = new bool[_colliders.Length];
				for (int i = 0; i < _colliders.Length; i++)
				{
					_originalColliderStates[i] = (Object)(object)_colliders[i] != (Object)null && _colliders[i].enabled;
				}
			}
			_lastCheckTime = Time.time;
		}

		private void Update()
		{
			if ((Object)(object)_nview == (Object)null || !_nview.IsValid() || !_nview.IsOwner())
			{
				return;
			}
			if (!Plugin.TamedIdleOptimizationEnabled.Value)
			{
				if (_isInIdleMode)
				{
					ExitIdleMode();
				}
				return;
			}
			float time = Time.time;
			if (time - _lastCheckTime < 1f)
			{
				return;
			}
			_lastCheckTime = time;
			if ((Object)(object)_character != (Object)null && _character.InAttack())
			{
				_lastCombatTime = time;
			}
			if (_isInIdleMode)
			{
				if (ShouldExitIdle())
				{
					ExitIdleMode();
				}
			}
			else if (ShouldEnterIdle())
			{
				EnterIdleMode();
			}
		}

		private bool ShouldEnterIdle()
		{
			if (Time.time - _lastStateChange < 2f)
			{
				return false;
			}
			if ((Object)(object)_baseAI != (Object)null && (Object)(object)_baseAI.GetTargetCreature() != (Object)null)
			{
				return false;
			}
			if (IsTamed() && !IsInCombat() && GetCachedInsideBase() && !HasFollowTarget())
			{
				return Time.time - _lastCombatTime > Plugin.TamedIdleDistanceFromCombat.Value;
			}
			return false;
		}

		private bool ShouldExitIdle()
		{
			if (!IsInCombat() && !HasFollowTarget() && !PlayerIsNearby())
			{
				return !GetCachedInsideBase();
			}
			return true;
		}

		private bool IsTamed()
		{
			if ((Object)(object)_character != (Object)null)
			{
				return _character.IsTamed();
			}
			return false;
		}

		private bool IsInCombat()
		{
			if ((Object)(object)_character == (Object)null)
			{
				return false;
			}
			if (_character.InAttack())
			{
				return true;
			}
			if ((Object)(object)_baseAI != (Object)null)
			{
				if (_baseAI.IsAlerted())
				{
					return true;
				}
				if ((Object)(object)_baseAI.GetTargetCreature() != (Object)null)
				{
					return true;
				}
				if (_baseAI.HaveTarget())
				{
					return true;
				}
			}
			if ((Object)(object)_monsterAI != (Object)null)
			{
				Character targetCreature = ((BaseAI)_monsterAI).GetTargetCreature();
				if ((Object)(object)targetCreature != (Object)null && !targetCreature.IsDead())
				{
					return true;
				}
			}
			return false;
		}

		private bool GetCachedInsideBase()
		{
			float time = Time.time;
			if (time - _lastBaseCheckTime < 5f)
			{
				return _cachedInsideBase;
			}
			_lastBaseCheckTime = time;
			_cachedInsideBase = IsInsideBase();
			return _cachedInsideBase;
		}

		private bool IsInsideBase()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (PrivateArea.CheckAccess(((Component)this).transform.position, 0f, false, false))
			{
				return true;
			}
			float num = Plugin.TamedIdleBaseDetectionRadius?.Value ?? 30f;
			return Physics.OverlapSphere(((Component)this).transform.position, num, _pieceMask).Length != 0;
		}

		private bool HasFollowTarget()
		{
			if ((Object)(object)_monsterAI != (Object)null)
			{
				return (Object)(object)_monsterAI.GetFollowTarget() != (Object)null;
			}
			return false;
		}

		private bool PlayerIsNearby()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			Vector3 val = ((Component)Player.m_localPlayer).transform.position - ((Component)this).transform.position;
			return ((Vector3)(ref val)).sqrMagnitude < 25f;
		}

		private void EnterIdleMode()
		{
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			if (_isInIdleMode)
			{
				return;
			}
			if (Plugin.DebugLoggingEnabled.Value)
			{
				Plugin.Log.LogInfo((object)("[TamedIdle] " + ((Object)((Component)this).gameObject).name + " → IDLE"));
			}
			if ((Object)(object)_baseAI != (Object)null)
			{
				_originalAIEnabled = ((Behaviour)_baseAI).enabled;
				((Behaviour)_baseAI).enabled = false;
				_baseAI.StopMoving();
				MonsterAI monsterAI = _monsterAI;
				if (monsterAI != null)
				{
					monsterAI.SetFollowTarget((GameObject)null);
				}
			}
			if ((Object)(object)_animator != (Object)null)
			{
				_originalAnimatorSpeed = _animator.speed;
				_animator.speed = 0f;
				((Behaviour)_animator).enabled = false;
			}
			if (_colliders != null)
			{
				for (int i = 0; i < _colliders.Length; i++)
				{
					Collider val = _colliders[i];
					if ((Object)(object)val != (Object)null)
					{
						_originalColliderStates[i] = val.enabled;
						val.enabled = false;
					}
				}
			}
			if ((Object)(object)_rigidbody != (Object)null && !_rigidbody.isKinematic)
			{
				_rigidbody.velocity = Vector3.zero;
				_rigidbody.angularVelocity = Vector3.zero;
				_rigidbody.isKinematic = true;
			}
			_isInIdleMode = true;
			_lastStateChange = Time.time;
		}

		private void ExitIdleMode()
		{
			if (!_isInIdleMode)
			{
				return;
			}
			if (Plugin.DebugLoggingEnabled.Value)
			{
				Plugin.Log.LogInfo((object)("[TamedIdle] " + ((Object)((Component)this).gameObject).name + " → ACTIVE"));
			}
			if (_colliders != null && _originalColliderStates != null)
			{
				for (int i = 0; i < _colliders.Length; i++)
				{
					Collider val = _colliders[i];
					if ((Object)(object)val != (Object)null)
					{
						val.enabled = _originalColliderStates[i];
					}
				}
			}
			if ((Object)(object)_rigidbody != (Object)null)
			{
				_rigidbody.isKinematic = _originalRigidbodyKinematic;
			}
			if ((Object)(object)_baseAI != (Object)null)
			{
				((Behaviour)_baseAI).enabled = _originalAIEnabled;
			}
			if ((Object)(object)_animator != (Object)null)
			{
				((Behaviour)_animator).enabled = true;
				_animator.speed = _originalAnimatorSpeed;
			}
			_isInIdleMode = false;
			_lastStateChange = Time.time;
		}

		private void OnDestroy()
		{
			if (_isInIdleMode)
			{
				ExitIdleMode();
			}
		}
	}
}