using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dawn;
using GameNetcodeStuff;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using Y4NGZDreadweaver.AI;
using Y4NGZDreadweaver.NetcodePatcher;
using Y4NGZMonsters.Shared;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Y4NGZDreadweaver")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+25ca94fed298fe073d4c739917e3b7f046e875bf")]
[assembly: AssemblyProduct("Y4NGZDreadweaver")]
[assembly: AssemblyTitle("Y4NGZDreadweaver")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Y4NGZDreadweaver
{
	internal sealed class DreadweaverConfig
	{
		public ConfigEntry<bool> Enabled { get; }

		public ConfigEntry<float> SpawnWeightMultiplier { get; }

		public ConfigEntry<int> MaxCount { get; }

		public ConfigEntry<float> PowerLevel { get; }

		public ConfigEntry<int> Health { get; }

		public ConfigEntry<float> SightingIntervalMinSeconds { get; }

		public ConfigEntry<float> SightingIntervalMaxSeconds { get; }

		public ConfigEntry<float> AttackDelayMinSeconds { get; }

		public ConfigEntry<float> AttackDelayMaxSeconds { get; }

		public ConfigEntry<float> StalkMoveSpeed { get; }

		public ConfigEntry<float> CrawlSpeed { get; }

		public ConfigEntry<float> AttackSpeed { get; }

		public ConfigEntry<int> AttackDamage { get; }

		public ConfigEntry<float> AttackCooldown { get; }

		public ConfigEntry<bool> CreatureSpotlightEnabled { get; }

		public ConfigEntry<bool> FlashlightHarassEnabled { get; }

		public ConfigEntry<bool> DebugLogs { get; }

		public DreadweaverConfig(ConfigFile config)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Expected O, but got Unknown
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Expected O, but got Unknown
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Expected O, but got Unknown
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Expected O, but got Unknown
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Expected O, but got Unknown
			bool saveOnConfigSet = config.SaveOnConfigSet;
			config.SaveOnConfigSet = false;
			try
			{
				DreadweaverConfigMigration.TryMigrate(config, Plugin.Log);
				ConfigSectionNameMigration.TryMigrate(config, Plugin.Log, "Dreadweaver");
				Enabled = config.Bind<bool>("General", "Enabled", true, "Enable the Dreadweaver encounter.");
				SpawnWeightMultiplier = config.Bind<float>("Spawning", "SpawnWeightMultiplier", 1f, new ConfigDescription("Multiplier applied to Dreadweaver's contextual moon/interior spawn policy. 0 disables natural spawns.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>()));
				MaxCount = config.Bind<int>("Spawning", "MaxCount", 1, new ConfigDescription("Maximum number of living Dreadweavers at once.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 4), Array.Empty<object>()));
				PowerLevel = config.Bind<float>("Spawning", "PowerLevel", 2.8f, new ConfigDescription("Indoor enemy power budget cost for each Dreadweaver.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 20f), Array.Empty<object>()));
				Health = config.Bind<int>("Core Stats", "Health", 5, new ConfigDescription("Hits the Dreadweaver can take before dying.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
				SightingIntervalMinSeconds = config.Bind<float>("Encounter Pacing", "SightingIntervalMinSeconds", 45f, new ConfigDescription("Minimum hidden time between completed sightings.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(8f, 120f), Array.Empty<object>()));
				SightingIntervalMaxSeconds = config.Bind<float>("Encounter Pacing", "SightingIntervalMaxSeconds", 65f, new ConfigDescription("Maximum hidden time between completed sightings; values below the minimum are raised at runtime.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(8f, 150f), Array.Empty<object>()));
				AttackDelayMinSeconds = config.Bind<float>("Encounter Pacing", "AttackDelayMinSeconds", 15f, new ConfigDescription("Minimum hidden time between the final sighting and attack reveal.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 60f), Array.Empty<object>()));
				AttackDelayMaxSeconds = config.Bind<float>("Encounter Pacing", "AttackDelayMaxSeconds", 30f, new ConfigDescription("Maximum hidden time before attack reveal; values below the minimum are raised at runtime.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 90f), Array.Empty<object>()));
				StalkMoveSpeed = config.Bind<float>("Movement", "StalkMoveSpeed", 1.5f, new ConfigDescription("Movement speed outside committed attacks.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 4f), Array.Empty<object>()));
				CrawlSpeed = config.Bind<float>("Movement", "CrawlSpeed", 2.1f, new ConfigDescription("Movement speed during a crawl attack reveal.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.8f, 4f), Array.Empty<object>()));
				AttackSpeed = config.Bind<float>("Movement", "AttackSpeed", 5.15f, new ConfigDescription("Movement speed during committed pursuit.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 9f), Array.Empty<object>()));
				AttackDamage = config.Bind<int>("Combat", "AttackDamage", 40, new ConfigDescription("Damage dealt by a successful strike.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
				AttackCooldown = config.Bind<float>("Combat", "AttackCooldown", 1.8f, new ConfigDescription("Minimum recovery between attack attempts.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 6f), Array.Empty<object>()));
				CreatureSpotlightEnabled = config.Bind<bool>("Presentation", "CreatureSpotlightEnabled", true, "Light the visible Dreadweaver so the encounter remains readable in dark interiors.");
				FlashlightHarassEnabled = config.Bind<bool>("Presentation", "FlashlightHarassEnabled", true, "Briefly glitch the stalked player's flashlight or helmet lamp when it cloaks nearby.");
				DebugLogs = config.Bind<bool>("Diagnostics", "DebugLogs", false, "Log detailed Dreadweaver targeting and setup diagnostics.");
			}
			finally
			{
				config.SaveOnConfigSet = saveOnConfigSet;
				if (saveOnConfigSet)
				{
					config.Save();
				}
			}
		}
	}
	internal static class DreadweaverConfigMigration
	{
		private static readonly ConfigDefinition LegacySpawnWeight = new ConfigDefinition("Spawning", "SpawnWeight");

		private static readonly ConfigDefinition[] RetainedLegacyDefinitions = (ConfigDefinition[])(object)new ConfigDefinition[15]
		{
			new ConfigDefinition("Spawning", "MaxCount"),
			new ConfigDefinition("Spawning", "PowerLevel"),
			new ConfigDefinition("Stats", "Health"),
			new ConfigDefinition("Movement", "StalkMoveSpeed"),
			new ConfigDefinition("Movement", "CrawlSpeed"),
			new ConfigDefinition("Movement", "AttackSpeed"),
			new ConfigDefinition("Sightings", "SightingIntervalMinSeconds"),
			new ConfigDefinition("Sightings", "SightingIntervalMaxSeconds"),
			new ConfigDefinition("Attack", "AttackDelayMinSeconds"),
			new ConfigDefinition("Attack", "AttackDelayMaxSeconds"),
			new ConfigDefinition("Attack", "AttackDamage"),
			new ConfigDefinition("Attack", "AttackCooldown"),
			new ConfigDefinition("Visuals", "CreatureSpotlightEnabled"),
			new ConfigDefinition("Visuals", "FlashlightHarassEnabled"),
			new ConfigDefinition("Debug", "DebugLogs")
		};

		private static readonly Dictionary<ConfigDefinition, string> RemovedDefaults = new Dictionary<ConfigDefinition, string>
		{
			{
				new ConfigDefinition("Spawning", "LevelMask"),
				"-1"
			},
			{
				new ConfigDefinition("Stats", "ModelScale"),
				"1.75"
			},
			{
				new ConfigDefinition("Movement", "TurnSpeed"),
				"420"
			},
			{
				new ConfigDefinition("Movement", "Acceleration"),
				"18"
			},
			{
				new ConfigDefinition("Sightings", "LongSightingMinDistance"),
				"30"
			},
			{
				new ConfigDefinition("Sightings", "LongSightingMaxDistance"),
				"50"
			},
			{
				new ConfigDefinition("Sightings", "LongSightingHoldSeconds"),
				"1.35"
			},
			{
				new ConfigDefinition("Sightings", "MediumSightingMinDistance"),
				"15"
			},
			{
				new ConfigDefinition("Sightings", "MediumSightingMaxDistance"),
				"30"
			},
			{
				new ConfigDefinition("Sightings", "MediumSightingHoldSeconds"),
				"1.15"
			},
			{
				new ConfigDefinition("Sightings", "ShortSightingMinDistance"),
				"4"
			},
			{
				new ConfigDefinition("Sightings", "ShortSightingMaxDistance"),
				"8"
			},
			{
				new ConfigDefinition("Sightings", "ShortSightingHoldSeconds"),
				"1"
			},
			{
				new ConfigDefinition("Sightings", "SightingRetryMinSeconds"),
				"15"
			},
			{
				new ConfigDefinition("Sightings", "SightingRetryMaxSeconds"),
				"30"
			},
			{
				new ConfigDefinition("Sightings", "SightingTimeoutSeconds"),
				"12"
			},
			{
				new ConfigDefinition("Sightings", "PlayerSpotAngle"),
				"25"
			},
			{
				new ConfigDefinition("Sightings", "CreatureSightRange"),
				"60"
			},
			{
				new ConfigDefinition("Stalking ambience", "LightFlickerRadius"),
				"18"
			},
			{
				new ConfigDefinition("Stalking ambience", "LightFlickerIntervalMinSeconds"),
				"40"
			},
			{
				new ConfigDefinition("Stalking ambience", "LightFlickerIntervalMaxSeconds"),
				"70"
			},
			{
				new ConfigDefinition("Stalking ambience", "DoorSlamRadius"),
				"14"
			},
			{
				new ConfigDefinition("Stalking ambience", "DoorSlamIntervalMinSeconds"),
				"35"
			},
			{
				new ConfigDefinition("Stalking ambience", "DoorSlamIntervalMaxSeconds"),
				"70"
			},
			{
				new ConfigDefinition("Attack", "AttackRevealMinDistance"),
				"8"
			},
			{
				new ConfigDefinition("Attack", "AttackRevealMaxDistance"),
				"16"
			},
			{
				new ConfigDefinition("Attack", "CrawlAdvanceSeconds"),
				"3"
			},
			{
				new ConfigDefinition("Attack", "AttackRange"),
				"2.35"
			},
			{
				new ConfigDefinition("Attack", "AttackDamageDelay"),
				"0.48"
			},
			{
				new ConfigDefinition("Attack", "AttackHitArcDegrees"),
				"120"
			},
			{
				new ConfigDefinition("Attack", "AttackLoseDistance"),
				"48"
			},
			{
				new ConfigDefinition("Attack", "AttackLostSightGraceSeconds"),
				"12"
			},
			{
				new ConfigDefinition("Attack", "PursuitRepositionCooldownMinSeconds"),
				"2"
			},
			{
				new ConfigDefinition("Attack", "PursuitRepositionCooldownMaxSeconds"),
				"5"
			},
			{
				new ConfigDefinition("Attack", "PursuitRepositionMinDistance"),
				"10"
			},
			{
				new ConfigDefinition("Attack", "ChainAttackRadius"),
				"13"
			},
			{
				new ConfigDefinition("Camo", "VanishFlickerSeconds"),
				"0.65"
			},
			{
				new ConfigDefinition("Camo", "DecloakFlickerSeconds"),
				"0.55"
			},
			{
				new ConfigDefinition("Animation", "MatchAnimationToMovement"),
				"true"
			},
			{
				new ConfigDefinition("Animation", "AuthoredWalkSpeed"),
				"1.9"
			},
			{
				new ConfigDefinition("Animation", "AuthoredCrawlSpeed"),
				"1.9"
			},
			{
				new ConfigDefinition("Animation", "AuthoredRunSpeed"),
				"3.6"
			},
			{
				new ConfigDefinition("Visuals", "CreatureSpotlightIntensity"),
				"18"
			},
			{
				new ConfigDefinition("Visuals", "CreatureSpotlightRange"),
				"14"
			},
			{
				new ConfigDefinition("Visuals", "CreatureSpotlightAngle"),
				"42"
			},
			{
				new ConfigDefinition("Visuals", "CreatureSpotlightHeight"),
				"5"
			},
			{
				new ConfigDefinition("Visuals", "DramaticSpotlightChance"),
				"0.35"
			}
		};

		internal static bool TryMigrate(ConfigFile config, ManualLogSource log)
		{
			string configFilePath = config.ConfigFilePath;
			if (!File.Exists(configFilePath))
			{
				return false;
			}
			Dictionary<ConfigDefinition, string> dictionary = null;
			string text = null;
			try
			{
				dictionary = ReadValues(configFilePath);
				if (!ContainsLegacyConfig(dictionary))
				{
					return false;
				}
				text = GetBackupPath(configFilePath);
				File.Copy(configFilePath, text, overwrite: false);
				File.WriteAllText(configFilePath, BuildMigratedConfig(dictionary), new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
				config.Reload();
			}
			catch (Exception ex)
			{
				string text2 = "The original config was not modified.";
				if (!string.IsNullOrEmpty(text) && File.Exists(text))
				{
					try
					{
						File.Copy(text, configFilePath, overwrite: true);
						config.Reload();
						text2 = "The original config was restored from its backup.";
					}
					catch (Exception ex2)
					{
						text2 = "Automatic restore also failed: " + ex2.GetBaseException().Message + ". Recover manually from " + text + ".";
					}
				}
				if (log != null)
				{
					log.LogWarning((object)("[Dreadweaver] Could not migrate legacy config: " + ex.GetBaseException().Message + " " + text2));
				}
				return false;
			}
			List<string> list = FindCustomizedDroppedKeys(dictionary);
			if (log != null)
			{
				log.LogInfo((object)("[Dreadweaver] Migrated legacy config to the compact DawnLib layout. Backup: " + text));
			}
			if (list.Count > 0 && log != null)
			{
				log.LogWarning((object)("[Dreadweaver] These customized legacy settings are now authored source tuning and were not carried forward: " + string.Join(", ", list)));
			}
			return true;
		}

		private static bool ContainsLegacyConfig(Dictionary<ConfigDefinition, string> values)
		{
			if (values.ContainsKey(LegacySpawnWeight))
			{
				return true;
			}
			for (int i = 0; i < RetainedLegacyDefinitions.Length; i++)
			{
				if (values.ContainsKey(RetainedLegacyDefinitions[i]))
				{
					return true;
				}
			}
			foreach (ConfigDefinition key in RemovedDefaults.Keys)
			{
				if (values.ContainsKey(key))
				{
					return true;
				}
			}
			return false;
		}

		private static string BuildMigratedConfig(Dictionary<ConfigDefinition, string> values)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00ed: 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_010b: Expected O, but got Unknown
			//IL_010b: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Expected O, but got Unknown
			//IL_0145: Expected O, but got Unknown
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_0190: Expected O, but got Unknown
			//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_01db: Expected O, but got Unknown
			//IL_01db: Expected O, but got Unknown
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			//IL_0215: Expected O, but got Unknown
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Expected O, but got Unknown
			//IL_024f: Expected O, but got Unknown
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Expected O, but got Unknown
			//IL_0289: Expected O, but got Unknown
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Expected O, but got Unknown
			//IL_02d4: Expected O, but got Unknown
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Expected O, but got Unknown
			//IL_030e: Expected O, but got Unknown
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Expected O, but got Unknown
			//IL_0348: Expected O, but got Unknown
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Expected O, but got Unknown
			//IL_0393: Expected O, but got Unknown
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Expected O, but got Unknown
			//IL_03cd: Expected O, but got Unknown
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Expected O, but got Unknown
			//IL_0418: Expected O, but got Unknown
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Expected O, but got Unknown
			//IL_0452: Expected O, but got Unknown
			//IL_047f: 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: Expected O, but got Unknown
			//IL_049d: Expected O, but got Unknown
			string text = GetValue(values, new ConfigDefinition("10 - Spawning", "SpawnWeightMultiplier"), null, null);
			if (string.IsNullOrWhiteSpace(text))
			{
				text = ((!float.TryParse(GetValue(values, LegacySpawnWeight, null, "12"), NumberStyles.Float, CultureInfo.InvariantCulture, out var result)) ? "1" : Math.Max(0f, Math.Min(5f, result / 12f)).ToString("0.###", CultureInfo.InvariantCulture));
			}
			StringBuilder stringBuilder = new StringBuilder();
			AppendSection(stringBuilder, "00 - General", ("Enabled", GetValue(values, new ConfigDefinition("00 - General", "Enabled"), null, "true")));
			AppendSection(stringBuilder, "10 - Spawning", ("SpawnWeightMultiplier", text), ("MaxCount", GetValue(values, new ConfigDefinition("10 - Spawning", "MaxCount"), new ConfigDefinition("Spawning", "MaxCount"), "1")), ("PowerLevel", GetValue(values, new ConfigDefinition("10 - Spawning", "PowerLevel"), new ConfigDefinition("Spawning", "PowerLevel"), "2.8")));
			AppendSection(stringBuilder, "20 - Core Stats", ("Health", GetValue(values, new ConfigDefinition("20 - Core Stats", "Health"), new ConfigDefinition("Stats", "Health"), "5")));
			AppendSection(stringBuilder, "30 - Encounter Pacing", ("SightingIntervalMinSeconds", GetValue(values, new ConfigDefinition("30 - Encounter Pacing", "SightingIntervalMinSeconds"), new ConfigDefinition("Sightings", "SightingIntervalMinSeconds"), "45")), ("SightingIntervalMaxSeconds", GetValue(values, new ConfigDefinition("30 - Encounter Pacing", "SightingIntervalMaxSeconds"), new ConfigDefinition("Sightings", "SightingIntervalMaxSeconds"), "65")), ("AttackDelayMinSeconds", GetValue(values, new ConfigDefinition("30 - Encounter Pacing", "AttackDelayMinSeconds"), new ConfigDefinition("Attack", "AttackDelayMinSeconds"), "15")), ("AttackDelayMaxSeconds", GetValue(values, new ConfigDefinition("30 - Encounter Pacing", "AttackDelayMaxSeconds"), new ConfigDefinition("Attack", "AttackDelayMaxSeconds"), "30")));
			AppendSection(stringBuilder, "40 - Movement", ("StalkMoveSpeed", GetValue(values, new ConfigDefinition("40 - Movement", "StalkMoveSpeed"), new ConfigDefinition("Movement", "StalkMoveSpeed"), "1.5")), ("CrawlSpeed", GetValue(values, new ConfigDefinition("40 - Movement", "CrawlSpeed"), new ConfigDefinition("Movement", "CrawlSpeed"), "2.1")), ("AttackSpeed", GetValue(values, new ConfigDefinition("40 - Movement", "AttackSpeed"), new ConfigDefinition("Movement", "AttackSpeed"), "5.15")));
			AppendSection(stringBuilder, "50 - Combat", ("AttackDamage", GetValue(values, new ConfigDefinition("50 - Combat", "AttackDamage"), new ConfigDefinition("Attack", "AttackDamage"), "40")), ("AttackCooldown", GetValue(values, new ConfigDefinition("50 - Combat", "AttackCooldown"), new ConfigDefinition("Attack", "AttackCooldown"), "1.8")));
			AppendSection(stringBuilder, "60 - Presentation", ("CreatureSpotlightEnabled", GetValue(values, new ConfigDefinition("60 - Presentation", "CreatureSpotlightEnabled"), new ConfigDefinition("Visuals", "CreatureSpotlightEnabled"), "true")), ("FlashlightHarassEnabled", GetValue(values, new ConfigDefinition("60 - Presentation", "FlashlightHarassEnabled"), new ConfigDefinition("Visuals", "FlashlightHarassEnabled"), "true")));
			AppendSection(stringBuilder, "99 - Diagnostics", ("DebugLogs", GetValue(values, new ConfigDefinition("99 - Diagnostics", "DebugLogs"), new ConfigDefinition("Debug", "DebugLogs"), "false")));
			return stringBuilder.ToString();
		}

		private static void AppendSection(StringBuilder output, string section, params (string Key, string Value)[] entries)
		{
			output.Append('[').Append(section).AppendLine("]");
			for (int i = 0; i < entries.Length; i++)
			{
				output.Append(entries[i].Key).Append(" = ").AppendLine(entries[i].Value);
			}
			output.AppendLine();
		}

		private static string GetValue(Dictionary<ConfigDefinition, string> values, ConfigDefinition preferred, ConfigDefinition legacy, string fallback)
		{
			if (preferred != (ConfigDefinition)null && values.TryGetValue(preferred, out var value))
			{
				return value;
			}
			if (legacy != (ConfigDefinition)null && values.TryGetValue(legacy, out value))
			{
				return value;
			}
			return fallback;
		}

		private static Dictionary<ConfigDefinition, string> ReadValues(string path)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			Dictionary<ConfigDefinition, string> dictionary = new Dictionary<ConfigDefinition, string>();
			string text = string.Empty;
			string[] array = File.ReadAllLines(path);
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0 || text2.StartsWith("#", StringComparison.Ordinal))
				{
					continue;
				}
				if (text2.StartsWith("[", StringComparison.Ordinal) && text2.EndsWith("]", StringComparison.Ordinal))
				{
					text = text2.Substring(1, text2.Length - 2);
					continue;
				}
				int num = text2.IndexOf('=');
				if (num > 0)
				{
					string text3 = text2.Substring(0, num).Trim();
					string value = text2.Substring(num + 1).Trim();
					dictionary[new ConfigDefinition(text, text3)] = value;
				}
			}
			return dictionary;
		}

		private static List<string> FindCustomizedDroppedKeys(Dictionary<ConfigDefinition, string> values)
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<ConfigDefinition, string> removedDefault in RemovedDefaults)
			{
				if (values.TryGetValue(removedDefault.Key, out var value) && !ValuesEquivalent(value, removedDefault.Value))
				{
					list.Add(removedDefault.Key.Section + "." + removedDefault.Key.Key);
				}
			}
			list.Sort(StringComparer.OrdinalIgnoreCase);
			return list;
		}

		private static bool ValuesEquivalent(string left, string right)
		{
			if (string.Equals(left.Trim(), right.Trim(), StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (float.TryParse(left, NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(right, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
			{
				return Math.Abs(result - result2) < 0.0001f;
			}
			return false;
		}

		private static string GetBackupPath(string configPath)
		{
			string text = configPath + ".pre-dawn.bak";
			if (!File.Exists(text))
			{
				return text;
			}
			for (int i = 2; i < 1000; i++)
			{
				string text2 = configPath + $".pre-dawn.{i}.bak";
				if (!File.Exists(text2))
				{
					return text2;
				}
			}
			throw new IOException("Could not allocate a Dreadweaver config backup filename.");
		}
	}
	internal sealed class DreadweaverSpawnWeights : IWeighted, IContextualWeighted<SpawnWeightContext>
	{
		internal const int DefaultWeight = 3;

		internal const int MaximumWeight = 100;

		private readonly Func<float> _multiplier;

		internal DreadweaverSpawnWeights(Func<float> multiplier)
		{
			_multiplier = multiplier ?? throw new ArgumentNullException("multiplier");
		}

		public int GetWeight()
		{
			return Scale(3, 1f);
		}

		public int GetWeight(SpawnWeightContext context)
		{
			int moonWeight = GetMoonWeight(((SpawnWeightContext)(ref context)).Moon);
			if (moonWeight <= 0)
			{
				return 0;
			}
			return Scale(moonWeight, GetDungeonMultiplier(((SpawnWeightContext)(ref context)).Dungeon));
		}

		internal static int GetMoonWeight(DawnMoonInfo moon)
		{
			if (moon == null)
			{
				return 3;
			}
			if (((DawnBaseInfo<DawnMoonInfo>)(object)moon).HasTag(Tags.Company) || ((DawnBaseInfo<DawnMoonInfo>)(object)moon).HasTag(Tags.Unimplemented) || KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.Test))
			{
				return 0;
			}
			if (KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.Experimentation))
			{
				return 1;
			}
			if (KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.Assurance) || KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.Vow))
			{
				return 3;
			}
			if (KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.Offense) || KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.March) || KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.Embrion))
			{
				return 5;
			}
			if (KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.Adamance))
			{
				return 7;
			}
			if (KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.Rend) || KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.Dine))
			{
				return 9;
			}
			if (KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.Titan) || KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.Artifice) || KeyEquals<DawnMoonInfo>(((DawnBaseInfo<DawnMoonInfo>)(object)moon).TypedKey, MoonKeys.Liquidation))
			{
				return 11;
			}
			if (((DawnBaseInfo<DawnMoonInfo>)(object)moon).HasTag(Tags.Paid))
			{
				return 8;
			}
			((DawnBaseInfo<DawnMoonInfo>)(object)moon).HasTag(Tags.Free);
			return 3;
		}

		internal static float GetDungeonMultiplier(DawnDungeonInfo dungeon)
		{
			if (dungeon == null)
			{
				return 1f;
			}
			if (KeyEquals<DawnDungeonInfo>(((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).TypedKey, DungeonKeys.MansionFlow) || ((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).HasTag(Tags.Gothic) || ((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).HasTag(Tags.Grand) || ((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).HasTag(Tags.Ornate) || ((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).HasTag(Tags.Lavish) || ((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).HasTag(Tags.Eerie))
			{
				return 1.25f;
			}
			if (KeyEquals<DawnDungeonInfo>(((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).TypedKey, DungeonKeys.FacilityFlow) || KeyEquals<DawnDungeonInfo>(((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).TypedKey, DungeonKeys.FacilityFlowThreeExits) || KeyEquals<DawnDungeonInfo>(((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).TypedKey, DungeonKeys.FacilityFlowExtraLarge) || ((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).HasTag(Tags.Industrial) || ((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).HasTag(Tags.Mechanical) || ((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).HasTag(Tags.Factory) || ((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).HasTag(Tags.Bunker))
			{
				return 1f;
			}
			if (KeyEquals<DawnDungeonInfo>(((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).TypedKey, DungeonKeys.MineshaftFlow) || ((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).HasTag(Tags.Cavern) || ((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).HasTag(Tags.Quarry) || ((DawnBaseInfo<DawnDungeonInfo>)(object)dungeon).HasTag(Tags.Flooded))
			{
				return 0.5f;
			}
			return 0.75f;
		}

		private int Scale(int moonWeight, float dungeonMultiplier)
		{
			float num = Mathf.Clamp(_multiplier(), 0f, 5f);
			return Mathf.Clamp(Mathf.RoundToInt((float)moonWeight * dungeonMultiplier * num), 0, 100);
		}

		private static bool KeyEquals<T>(NamespacedKey<T> left, NamespacedKey<T> right) where T : INamespaced
		{
			if (left != null && right != null)
			{
				return ((object)left).Equals((object?)right);
			}
			return false;
		}
	}
	internal static class DreadweaverTuning
	{
		internal const float ModelScale = 1.75f;

		internal const float TurnSpeed = 420f;

		internal const float Acceleration = 18f;

		internal const float AgentRadius = 0.86f;

		internal const float AgentHeight = 2.45f;

		internal const float LongSightingMinDistance = 30f;

		internal const float LongSightingMaxDistance = 50f;

		internal const float LongSightingHoldSeconds = 1.35f;

		internal const float MediumSightingMinDistance = 15f;

		internal const float MediumSightingMaxDistance = 30f;

		internal const float MediumSightingHoldSeconds = 1.15f;

		internal const float ShortSightingMinDistance = 4f;

		internal const float ShortSightingMaxDistance = 8f;

		internal const float ShortSightingHoldSeconds = 1f;

		internal const float SightingRetryMinSeconds = 15f;

		internal const float SightingRetryMaxSeconds = 30f;

		internal const float SightingTimeoutSeconds = 12f;

		internal const float PlayerSpotAngle = 25f;

		internal const float CreatureSightRange = 60f;

		internal const float StalkLightFlickerRadius = 18f;

		internal const float StalkLightFlickerIntervalMinSeconds = 40f;

		internal const float StalkLightFlickerIntervalMaxSeconds = 70f;

		internal const float StalkDoorSlamRadius = 14f;

		internal const float StalkDoorSlamIntervalMinSeconds = 35f;

		internal const float StalkDoorSlamIntervalMaxSeconds = 70f;

		internal const float AttackRevealMinDistance = 8f;

		internal const float AttackRevealMaxDistance = 16f;

		internal const float CrawlAdvanceSeconds = 3f;

		internal const float AttackRange = 2.35f;

		internal const float AttackDamageDelay = 0.48f;

		internal const float AttackHitArcDegrees = 120f;

		internal const float AttackLoseDistance = 48f;

		internal const float AttackLostSightGraceSeconds = 12f;

		internal const float PursuitRepositionCooldownMinSeconds = 2f;

		internal const float PursuitRepositionCooldownMaxSeconds = 5f;

		internal const float PursuitRepositionMinDistance = 10f;

		internal const float ChainAttackRadius = 13f;

		internal const float VanishFlickerSeconds = 0.65f;

		internal const float DecloakFlickerSeconds = 0.55f;

		internal const bool MatchAnimationToMovement = true;

		internal const float AuthoredWalkSpeed = 1.9f;

		internal const float AuthoredCrawlSpeed = 1.9f;

		internal const float AuthoredRunSpeed = 3.6f;

		internal const float CreatureSpotlightIntensity = 18f;

		internal const float CreatureSpotlightRange = 14f;

		internal const float CreatureSpotlightAngle = 42f;

		internal const float CreatureSpotlightHeight = 5f;
	}
	[BepInPlugin("y4ngz.lethalcompany.dreadweaver", "Y4NGZ Dreadweaver", "0.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		internal const string BundleFilename = "dreadweaver.bundle";

		internal const string PrefabName = "SK_Dreadweaver";

		internal const string AlternatePrefabName = "Dreadweaver";

		internal const string DawnNamespace = "y4ngz_monsters";

		internal const string DawnEnemyKey = "dreadweaver";

		internal const string ScanNodeSubtitle = "";

		internal const string BestiaryText = "Dreadweaver\n\nDanger level: high\n\nA facility stalker that fixates on a single worker. It stages a sequence of sightings, each closer than the last, vanishing the moment it is approached or watched too long. A third, very close sighting means the hunt is nearly over.\n\n";

		internal static ManualLogSource Log;

		internal static DreadweaverConfig ModConfig;

		internal static AssetBundle ModAssets;

		internal static EnemyType DreadweaverEnemyType;

		private static bool _netcodeInitialized;

		private static bool _loggedScanNodeLayer;

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			try
			{
				InitializeNetcodeRPCs();
				ModConfig = new DreadweaverConfig(((BaseUnityPlugin)this).Config);
				if (!ModConfig.Enabled.Value)
				{
					Log.LogInfo((object)"Y4NGZ Dreadweaver is disabled by config.");
				}
				else
				{
					if (!LoadBundle())
					{
						return;
					}
					GameObject val = LoadBundlePrefab();
					if ((Object)(object)val == (Object)null)
					{
						Log.LogError((object)"Prefab 'SK_Dreadweaver' not found in dreadweaver.bundle.");
						DumpBundleAssets();
						return;
					}
					PreparePrefab(val);
					DreadweaverEnemyType = CreateEnemyType(val);
					DreadweaverAI component = val.GetComponent<DreadweaverAI>();
					if ((Object)(object)component != (Object)null)
					{
						((EnemyAI)component).enemyType = DreadweaverEnemyType;
					}
					RegisterWithDawn(val);
					Log.LogInfo((object)"Y4NGZ Dreadweaver v0.1.0 loaded. Registered as 'dreadweaver'.");
				}
			}
			catch (Exception arg)
			{
				Log.LogError((object)string.Format("[{0}] Initialization failed: {1}", "Y4NGZ Dreadweaver", arg));
			}
		}

		private static void RegisterWithDawn(GameObject prefab)
		{
			DreadweaverSpawnWeights spawnWeights = new DreadweaverSpawnWeights(() => ModConfig.SpawnWeightMultiplier.Value);
			DawnLib.RegisterNetworkPrefab(prefab);
			DawnLib.DefineEnemy(NamespacedKey<DawnEnemyInfo>.From("y4ngz_monsters", "dreadweaver"), DreadweaverEnemyType, (Action<EnemyInfoBuilder>)delegate(EnemyInfoBuilder builder)
			{
				((BaseInfoBuilder<DawnEnemyInfo, EnemyType, EnemyInfoBuilder>)(object)builder.DefineInside((Action<EnemyLocationBuilder>)delegate(EnemyLocationBuilder location)
				{
					location.SetWeights((Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>)delegate(WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> table)
					{
						table.SetGlobalWeight((IWeighted)(object)spawnWeights);
					});
				}).CreateBestiaryNode("Dreadweaver\n\nDanger level: high\n\nA facility stalker that fixates on a single worker. It stages a sequence of sightings, each closer than the last, vanishing the moment it is approached or watched too long. A third, very close sighting means the hunt is nearly over.\n\n").CreateNameKeyword("dreadweaver")).AddTags((IEnumerable<NamespacedKey>)(object)new NamespacedKey[5]
				{
					Tags.Hostile,
					Tags.Organic,
					Tags.Killable,
					Tags.Biped,
					Tags.Medium
				});
			});
		}

		private static void InitializeNetcodeRPCs()
		{
			if (_netcodeInitialized)
			{
				return;
			}
			_netcodeInitialized = true;
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			foreach (Type type in types)
			{
				MethodInfo[] methods;
				try
				{
					methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				}
				catch
				{
					continue;
				}
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false).Length == 0)
					{
						continue;
					}
					try
					{
						methodInfo.Invoke(null, null);
					}
					catch (Exception ex)
					{
						ManualLogSource log = Log;
						if (log != null)
						{
							log.LogWarning((object)("[NetcodeInit] " + type.Name + "." + methodInfo.Name + " failed: " + ex.Message));
						}
					}
				}
			}
		}

		private static bool LoadBundle()
		{
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			if (string.IsNullOrEmpty(directoryName))
			{
				Log.LogError((object)"Could not resolve plugin assembly directory.");
				return false;
			}
			string text = Path.Combine(directoryName, "dreadweaver.bundle");
			if (!File.Exists(text))
			{
				Log.LogError((object)("Missing asset bundle: " + text));
				return false;
			}
			ModAssets = AssetBundle.LoadFromFile(text);
			if ((Object)(object)ModAssets == (Object)null)
			{
				Log.LogError((object)("AssetBundle.LoadFromFile returned null for " + text + "."));
				return false;
			}
			return true;
		}

		private static GameObject LoadBundlePrefab()
		{
			GameObject val = ModAssets.LoadAsset<GameObject>("SK_Dreadweaver") ?? ModAssets.LoadAsset<GameObject>("Dreadweaver");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			string[] allAssetNames = ModAssets.GetAllAssetNames();
			foreach (string text in allAssetNames)
			{
				string text2 = text.Replace('\\', '/');
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text2);
				if (text2.EndsWith("/sk_dreadweaver.prefab", StringComparison.OrdinalIgnoreCase) || text2.EndsWith("/dreadweaver.prefab", StringComparison.OrdinalIgnoreCase) || string.Equals(fileNameWithoutExtension, "SK_Dreadweaver", StringComparison.OrdinalIgnoreCase) || string.Equals(fileNameWithoutExtension, "Dreadweaver", StringComparison.OrdinalIgnoreCase))
				{
					val = ModAssets.LoadAsset<GameObject>(text);
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
			}
			return null;
		}

		private static void PreparePrefab(GameObject prefab)
		{
			//IL_0029: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			AssignUniqueNetworkHash(prefab);
			prefab.SetActive(true);
			TrySetTag(prefab, "Enemy");
			TrySetLayer(prefab, "Enemies");
			prefab.transform.localScale = Vector3.one * 1.75f;
			DreadweaverAI dreadweaverAI = prefab.GetComponent<DreadweaverAI>();
			if ((Object)(object)dreadweaverAI == (Object)null)
			{
				dreadweaverAI = prefab.AddComponent<DreadweaverAI>();
			}
			if ((Object)(object)prefab.GetComponent<NetworkObject>() == (Object)null)
			{
				prefab.AddComponent<NetworkObject>();
			}
			Animator val = prefab.GetComponent<Animator>() ?? prefab.GetComponentInChildren<Animator>(true);
			if ((Object)(object)val != (Object)null)
			{
				val.applyRootMotion = false;
				val.cullingMode = (AnimatorCullingMode)0;
				dreadweaverAI.visualAnimator = val;
			}
			else
			{
				Log.LogWarning((object)"[Dreadweaver] Prefab has no Animator.");
			}
			NavMeshAgent val2 = prefab.GetComponent<NavMeshAgent>();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = prefab.AddComponent<NavMeshAgent>();
			}
			ConfigureAgent(val2);
			((EnemyAI)dreadweaverAI).agent = val2;
			((EnemyAI)dreadweaverAI).creatureSFX = FindOrCreateAudioSource(prefab.transform, "CreatureSFX", 42f);
			((EnemyAI)dreadweaverAI).creatureVoice = FindOrCreateAudioSource(prefab.transform, "CreatureVoice", 46f);
			((EnemyAI)dreadweaverAI).eye = FindOrCreateChild(prefab.transform, "EyeTransform", new Vector3(0f, 1.85f, 0.55f));
			dreadweaverAI.attackOrigin = FindOrCreateChild(prefab.transform, "AttackOrigin", new Vector3(0f, 1.2f, 0.95f));
			AssignDreadweaverAudio(dreadweaverAI);
			EnsureDreadweaverRendering(prefab, (EnemyAI)(object)dreadweaverAI);
			EnsureBehaviourStates(dreadweaverAI);
			EnsureScanNode(prefab);
			EnsureCollision(prefab, dreadweaverAI);
		}

		private static void ConfigureAgent(NavMeshAgent agent)
		{
			agent.speed = ModConfig.StalkMoveSpeed.Value;
			agent.angularSpeed = 420f;
			agent.acceleration = 18f;
			agent.stoppingDistance = Mathf.Max(0.5f, 1.5274999f);
			agent.radius = 0.86f;
			agent.height = 2.45f;
			agent.baseOffset = 0f;
			agent.autoBraking = true;
			agent.autoRepath = true;
			agent.updateRotation = false;
			agent.areaMask = -1;
			agent.obstacleAvoidanceType = (ObstacleAvoidanceType)4;
			agent.avoidancePriority = 31;
		}

		private static void EnsureDreadweaverRendering(GameObject prefab, EnemyAI ai)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			SkinnedMeshRenderer[] componentsInChildren = prefab.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			MeshRenderer[] componentsInChildren2 = prefab.GetComponentsInChildren<MeshRenderer>(true);
			ai.skinnedMeshRenderers = componentsInChildren;
			ai.meshRenderers = componentsInChildren2;
			Bounds localBounds = default(Bounds);
			((Bounds)(ref localBounds))..ctor(Vector3.up * 1.25f, new Vector3(7.5f, 5.5f, 7.5f));
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !IsRuntimeHelperRenderer((Renderer)(object)val))
				{
					ActivateRendererHierarchy(prefab.transform, ((Component)val).transform);
					((Component)val).gameObject.SetActive(true);
					((Renderer)val).enabled = true;
					((Renderer)val).forceRenderingOff = false;
					val.updateWhenOffscreen = true;
					((Renderer)val).localBounds = localBounds;
					((Renderer)val).shadowCastingMode = (ShadowCastingMode)1;
					((Renderer)val).receiveShadows = true;
					EnsureRendererHasOpaqueMaterial((Renderer)(object)val);
				}
			}
			foreach (MeshRenderer val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null) && !IsRuntimeHelperRenderer((Renderer)(object)val2))
				{
					ActivateRendererHierarchy(prefab.transform, ((Component)val2).transform);
					((Component)val2).gameObject.SetActive(true);
					((Renderer)val2).enabled = true;
					((Renderer)val2).forceRenderingOff = false;
					((Renderer)val2).shadowCastingMode = (ShadowCastingMode)1;
					((Renderer)val2).receiveShadows = true;
					EnsureRendererHasOpaqueMaterial((Renderer)(object)val2);
				}
			}
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"[DreadweaverRenderer] Prepared {componentsInChildren.Length} skinned renderer(s), {componentsInChildren2.Length} mesh renderer(s).");
			}
		}

		private static void ActivateRendererHierarchy(Transform prefabRoot, Transform rendererTransform)
		{
			Transform val = rendererTransform;
			while ((Object)(object)val != (Object)null)
			{
				if (!((Component)val).gameObject.activeSelf)
				{
					((Component)val).gameObject.SetActive(true);
				}
				if (!((Object)(object)val == (Object)(object)prefabRoot))
				{
					val = val.parent;
					continue;
				}
				break;
			}
		}

		private static bool IsRuntimeHelperRenderer(Renderer renderer)
		{
			Transform val = (((Object)(object)renderer != (Object)null) ? ((Component)renderer).transform : null);
			while ((Object)(object)val != (Object)null)
			{
				string text = ((Object)val).name ?? string.Empty;
				if (text.IndexOf("ScanNode", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Collision", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("MapDot", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		private static void EnsureRendererHasOpaqueMaterial(Renderer renderer)
		{
			Material[] array = renderer.sharedMaterials;
			if (array == null || array.Length == 0)
			{
				array = (Material[])(object)new Material[1];
			}
			bool flag = false;
			for (int i = 0; i < array.Length; i++)
			{
				Material val = array[i];
				if ((Object)(object)val == (Object)null || (Object)(object)val.shader == (Object)null || ShouldReplaceDreadweaverMaterial(val))
				{
					array[i] = CreateOpaqueDreadweaverMaterial(val);
					flag = true;
				}
				else
				{
					ForceOpaqueMaterial(val);
				}
			}
			if (flag)
			{
				renderer.sharedMaterials = array;
			}
		}

		private static bool ShouldReplaceDreadweaverMaterial(Material material)
		{
			string text = (((Object)(object)material.shader != (Object)null) ? ((Object)material.shader).name : string.Empty);
			if (text.IndexOf("InternalError", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			if (text.IndexOf("Standard", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			if (material.IsKeywordEnabled("_ALPHATEST_ON") || material.renderQueue == 2450 || material.renderQueue >= 3000)
			{
				return true;
			}
			return false;
		}

		private static Material CreateOpaqueDreadweaverMaterial(Material source)
		{
			//IL_0055: 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_005a: 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_00f4: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_0144: Expected O, but got Unknown
			Shader val = Shader.Find("HDRP/Lit") ?? Shader.Find("HDRP/Unlit") ?? Shader.Find("Universal Render Pipeline/Lit") ?? Shader.Find("Standard") ?? Shader.Find("Diffuse");
			Material val2 = (((Object)(object)val != (Object)null) ? new Material(val) : new Material(source));
			((Object)val2).name = "M_DreadweaverRuntimeVisible";
			Texture texture = (((Object)(object)source != (Object)null) ? source.mainTexture : null);
			Texture texture2 = (((Object)(object)source != (Object)null && source.HasProperty("_BumpMap")) ? source.GetTexture("_BumpMap") : null);
			Texture texture3 = (((Object)(object)source != (Object)null && source.HasProperty("_MetallicGlossMap")) ? source.GetTexture("_MetallicGlossMap") : null);
			Texture texture4 = (((Object)(object)source != (Object)null && source.HasProperty("_OcclusionMap")) ? source.GetTexture("_OcclusionMap") : null);
			SetMaterialTexture(val2, "_BaseColorMap", texture);
			SetMaterialTexture(val2, "_MainTex", texture);
			SetMaterialTexture(val2, "_NormalMap", texture2);
			SetMaterialTexture(val2, "_BumpMap", texture2);
			SetMaterialTexture(val2, "_MaskMap", texture3);
			SetMaterialTexture(val2, "_MetallicGlossMap", texture3);
			SetMaterialTexture(val2, "_OcclusionMap", texture4);
			ForceOpaqueMaterial(val2);
			return val2;
		}

		private static void ForceOpaqueMaterial(Material material)
		{
			//IL_0010: 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 (!((Object)(object)material == (Object)null))
			{
				SetMaterialColor(material, "_BaseColor", Color.white);
				SetMaterialColor(material, "_Color", Color.white);
				SetMaterialFloat(material, "_SurfaceType", 0f);
				SetMaterialFloat(material, "_BlendMode", 0f);
				SetMaterialFloat(material, "_AlphaCutoffEnable", 0f);
				SetMaterialFloat(material, "_AlphaClip", 0f);
				SetMaterialFloat(material, "_Cutoff", 0f);
				SetMaterialFloat(material, "_ZWrite", 1f);
				SetMaterialFloat(material, "_SrcBlend", 1f);
				SetMaterialFloat(material, "_DstBlend", 0f);
				SetMaterialFloat(material, "_AlphaSrcBlend", 1f);
				SetMaterialFloat(material, "_AlphaDstBlend", 0f);
				SetMaterialFloat(material, "_Mode", 0f);
				SetMaterialFloat(material, "_DoubleSidedEnable", 1f);
				SetMaterialFloat(material, "_CullMode", 0f);
				SetMaterialFloat(material, "_Cull", 0f);
				material.SetOverrideTag("RenderType", "Opaque");
				material.renderQueue = -1;
				material.DisableKeyword("_ALPHATEST_ON");
				material.DisableKeyword("_ALPHATESTENABLE_ON");
				material.DisableKeyword("_SURFACE_TYPE_TRANSPARENT");
				material.DisableKeyword("_ALPHABLEND_ON");
			}
		}

		private static void SetMaterialTexture(Material material, string propertyName, Texture texture)
		{
			if ((Object)(object)material != (Object)null && (Object)(object)texture != (Object)null && material.HasProperty(propertyName))
			{
				material.SetTexture(propertyName, texture);
			}
		}

		private static void SetMaterialColor(Material material, string propertyName, Color color)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)material != (Object)null && material.HasProperty(propertyName))
			{
				material.SetColor(propertyName, color);
			}
		}

		private static void SetMaterialFloat(Material material, string propertyName, float value)
		{
			if ((Object)(object)material != (Object)null && material.HasProperty(propertyName))
			{
				material.SetFloat(propertyName, value);
			}
		}

		private static void EnsureBehaviourStates(DreadweaverAI ai)
		{
			//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_001b: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0056: 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_0067: Expected O, but got Unknown
			//IL_0069: 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_007a: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//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_00a0: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			((EnemyAI)ai).enemyBehaviourStates = (EnemyBehaviourState[])(object)new EnemyBehaviourState[11]
			{
				new EnemyBehaviourState
				{
					name = "HiddenAcquireTarget"
				},
				new EnemyBehaviourState
				{
					name = "HiddenFindWatch"
				},
				new EnemyBehaviourState
				{
					name = "SightingVisible"
				},
				new EnemyBehaviourState
				{
					name = "HiddenBetweenSightings"
				},
				new EnemyBehaviourState
				{
					name = "HiddenPreAttackDelay"
				},
				new EnemyBehaviourState
				{
					name = "AttackSetup"
				},
				new EnemyBehaviourState
				{
					name = "CrawlAdvance"
				},
				new EnemyBehaviourState
				{
					name = "Pursuit"
				},
				new EnemyBehaviourState
				{
					name = "AttackVanishReposition"
				},
				new EnemyBehaviourState
				{
					name = "Hit"
				},
				new EnemyBehaviourState
				{
					name = "Dead"
				}
			};
			((EnemyAI)ai).currentBehaviourStateIndex = 0;
			((EnemyAI)ai).previousBehaviourStateIndex = 0;
			((EnemyAI)ai).currentBehaviourState = ((EnemyAI)ai).enemyBehaviourStates[0];
		}

		internal static void EnsureScanNode(GameObject prefab)
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			ScanNodeProperties val = null;
			ScanNodeProperties[] componentsInChildren = prefab.GetComponentsInChildren<ScanNodeProperties>(true);
			foreach (ScanNodeProperties val2 in componentsInChildren)
			{
				bool flag = val2.creatureScanID >= 0;
				bool flag2 = (Object)(object)val != (Object)null && val.creatureScanID >= 0;
				bool flag3 = string.Equals(((Object)((Component)val2).gameObject).name, "ScanNode", StringComparison.Ordinal);
				bool flag4 = (Object)(object)val != (Object)null && string.Equals(((Object)((Component)val).gameObject).name, "ScanNode", StringComparison.Ordinal);
				if ((Object)(object)val == (Object)null || (flag && !flag2) || (flag == flag2 && flag3 && !flag4))
				{
					val = val2;
				}
			}
			if (componentsInChildren.Length > 1)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)$"[Dreadweaver] Found {componentsInChildren.Length} scan nodes; retiring every duplicate.");
				}
			}
			for (int j = 0; j < componentsInChildren.Length; j++)
			{
				if ((Object)(object)componentsInChildren[j] != (Object)(object)val)
				{
					RetireExtraScanNode(componentsInChildren[j], val, prefab);
				}
			}
			Transform val3 = (((Object)(object)val != (Object)null) ? ((Component)val).transform : FindOrCreateChild(prefab.transform, "ScanNode", new Vector3(0f, 1.45f, 0f)));
			((Object)((Component)val3).gameObject).name = "ScanNode";
			TrySetTag(((Component)val3).gameObject, "DoNotSet");
			TrySetLayer(((Component)val3).gameObject, "ScanNode");
			EnsureHierarchyActive(val3, prefab.transform);
			((Component)val3).gameObject.SetActive(true);
			if (!_loggedScanNodeLayer)
			{
				_loggedScanNodeLayer = true;
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)($"[Dreadweaver] Scan node layer resolved to {((Component)val3).gameObject.layer} " + string.Format("(NameToLayer(\"ScanNode\")={0}, fallback 22); ", LayerMask.NameToLayer("ScanNode")) + $"active={((Component)val3).gameObject.activeInHierarchy}."));
				}
			}
			BoxCollider val4 = ((Component)val3).GetComponent<BoxCollider>();
			if ((Object)(object)val4 == (Object)null)
			{
				val4 = ((Component)val3).gameObject.AddComponent<BoxCollider>();
			}
			((Collider)val4).enabled = true;
			((Collider)val4).isTrigger = true;
			val4.center = Vector3.zero;
			val4.size = new Vector3(1.75f, 2.35f, 1.35f);
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)val3).gameObject.AddComponent<ScanNodeProperties>();
			}
			val.headerText = "Dreadweaver";
			val.subText = "";
			val.maxRange = 25;
			val.minRange = 1;
			val.requiresLineOfSight = true;
			val.nodeType = 1;
		}

		private static void RetireExtraScanNode(ScanNodeProperties extra, ScanNodeProperties preferred, GameObject root)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)extra == (Object)null)
			{
				return;
			}
			Scene scene;
			if ((Object)(object)((Component)extra).gameObject == (Object)(object)root || ((Object)(object)preferred != (Object)null && (Object)(object)((Component)extra).gameObject == (Object)(object)((Component)preferred).gameObject))
			{
				scene = root.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					Object.Destroy((Object)(object)extra);
				}
				else
				{
					Object.DestroyImmediate((Object)(object)extra, true);
				}
				return;
			}
			GameObject gameObject = ((Component)extra).gameObject;
			gameObject.SetActive(false);
			Collider[] components = gameObject.GetComponents<Collider>();
			for (int i = 0; i < components.Length; i++)
			{
				components[i].enabled = false;
			}
			scene = root.scene;
			if (((Scene)(ref scene)).IsValid())
			{
				Object.Destroy((Object)(object)gameObject);
			}
			else
			{
				Object.DestroyImmediate((Object)(object)gameObject, true);
			}
		}

		private static void EnsureCollision(GameObject prefab, DreadweaverAI ai)
		{
			//IL_002e: 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_00af: 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)
			CapsuleCollider obj = prefab.GetComponent<CapsuleCollider>() ?? prefab.AddComponent<CapsuleCollider>();
			((Collider)obj).isTrigger = false;
			obj.direction = 1;
			obj.center = new Vector3(0f, 1.18f, 0f);
			obj.radius = 0.86f;
			obj.height = 2.45f;
			Transform val = FindOrCreateChild(prefab.transform, "Collision", new Vector3(0f, 1.1f, 0f));
			TrySetTag(((Component)val).gameObject, "Enemy");
			TrySetLayer(((Component)val).gameObject, "Enemies");
			BoxCollider obj2 = ((Component)val).GetComponent<BoxCollider>() ?? ((Component)val).gameObject.AddComponent<BoxCollider>();
			((Collider)obj2).isTrigger = true;
			obj2.center = Vector3.zero;
			obj2.size = new Vector3(2.05f, 2.25f, 1.9f);
			Rigidbody obj3 = ((Component)val).GetComponent<Rigidbody>() ?? ((Component)val).gameObject.AddComponent<Rigidbody>();
			obj3.isKinematic = true;
			obj3.useGravity = false;
			obj3.detectCollisions = true;
			EnemyAICollisionDetect obj4 = ((Component)val).GetComponent<EnemyAICollisionDetect>() ?? ((Component)val).gameObject.AddComponent<EnemyAICollisionDetect>();
			obj4.mainScript = (EnemyAI)(object)ai;
			obj4.alwaysAllowHitting = true;
			obj4.canCollideWithEnemies = true;
			obj4.onlyCollideWhenGrounded = false;
		}

		private static EnemyType CreateEnemyType(GameObject prefab)
		{
			EnemyType obj = ScriptableObject.CreateInstance<EnemyType>();
			obj.enemyName = "Dreadweaver";
			obj.enemyPrefab = prefab;
			obj.PowerLevel = ModConfig.PowerLevel.Value;
			obj.DiversityPowerLevel = 1;
			obj.MaxCount = ModConfig.MaxCount.Value;
			obj.canDie = true;
			obj.canBeStunned = true;
			obj.canBeDestroyed = true;
			obj.stunTimeMultiplier = 1f;
			obj.stunGameDifficultyMultiplier = 1f;
			obj.destroyOnDeath = false;
			obj.doorSpeedMultiplier = 1.1f;
			obj.isOutsideEnemy = false;
			obj.isDaytimeEnemy = false;
			obj.normalizedTimeInDayToLeave = 1f;
			obj.probabilityCurve = AnimationCurve.Constant(0f, 1f, 1f);
			obj.numberSpawnedFalloff = AnimationCurve.Linear(0f, 1f, 1f, 0.35f);
			obj.useNumberSpawnedFalloff = true;
			obj.disableAnimatorWhenFar = false;
			return obj;
		}

		private static AudioSource FindOrCreateAudioSource(Transform parent, string childName, float maxDistance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Transform val = FindOrCreateChild(parent, childName, Vector3.zero);
			AudioSource obj = ((Component)val).GetComponent<AudioSource>() ?? ((Component)val).gameObject.AddComponent<AudioSource>();
			obj.playOnAwake = false;
			obj.spatialBlend = 1f;
			obj.rolloffMode = (AudioRolloffMode)1;
			obj.minDistance = 3f;
			obj.maxDistance = maxDistance;
			return obj;
		}

		private static void AssignDreadweaverAudio(DreadweaverAI ai)
		{
			if ((Object)(object)ai == (Object)null || (Object)(object)ModAssets == (Object)null)
			{
				return;
			}
			string[] allAssetNames = ModAssets.GetAllAssetNames();
			ai.spotClips = LoadAudioClipSet(allAssetNames, "Spot_01", "Spot_02", "Spot_03");
			ai.footstepClips = LoadAudioClipSet(allAssetNames, "Footstep Metal Running 1_01", "Footstep Metal Running 1_02", "Footstep Metal Running 1_03", "Footstep Metal Running 1_04", "Footstep Metal Running 1_05", "Footstep Metal Running 1_06", "Footstep Metal Running 1_07", "Footstep Metal Running 1_08");
			ai.initialAttackClip = LoadAudioClip(allAssetNames, "Jumpscare_InitialAttack_01");
			ai.spottedClip = ((ai.spotClips.Length != 0) ? ai.spotClips[0] : null);
			ai.attackClip = ai.initialAttackClip;
			if (ai.spotClips.Length != 3 || ai.footstepClips.Length != 8 || (Object)(object)ai.initialAttackClip == (Object)null)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)($"[DreadweaverAudio] Incomplete bundle audio: spots={ai.spotClips.Length}/3, " + $"footsteps={ai.footstepClips.Length}/8, initialAttack={(((Object)(object)ai.initialAttackClip != (Object)null) ? 1 : 0)}/1."));
				}
			}
			else
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)"[DreadweaverAudio] Loaded 3 stalking stingers, 8 footsteps, and 1 initial-attack jumpscare.");
				}
			}
		}

		private static AudioClip[] LoadAudioClipSet(string[] bundleAssets, params string[] clipNames)
		{
			List<AudioClip> list = new List<AudioClip>(clipNames.Length);
			for (int i = 0; i < clipNames.Length; i++)
			{
				AudioClip val = LoadAudioClip(bundleAssets, clipNames[i]);
				if ((Object)(object)val != (Object)null)
				{
					list.Add(val);
				}
			}
			return list.ToArray();
		}

		private static AudioClip LoadAudioClip(string[] bundleAssets, string clipName)
		{
			foreach (string text in bundleAssets)
			{
				if (string.Equals(Path.GetFileNameWithoutExtension(text), clipName, StringComparison.OrdinalIgnoreCase))
				{
					AudioClip val = ModAssets.LoadAsset<AudioClip>(text);
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
			}
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogWarning((object)("[DreadweaverAudio] Missing AudioClip '" + clipName + "' in dreadweaver.bundle."));
			}
			return null;
		}

		private static Transform FindOrCreateChild(Transform parent, string name, Vector3 localPosition)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Transform val = parent.Find(name);
			if ((Object)(object)val != (Object)null)
			{
				val.localPosition = localPosition;
				return val;
			}
			val = new GameObject(name).transform;
			val.SetParent(parent, false);
			val.localPosition = localPosition;
			return val;
		}

		private static void AssignUniqueNetworkHash(GameObject prefab)
		{
			try
			{
				NetworkObject val = prefab.GetComponent<NetworkObject>();
				if ((Object)(object)val == (Object)null)
				{
					val = prefab.AddComponent<NetworkObject>();
				}
				uint num = BitConverter.ToUInt32(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes("y4ngz.lethalcompany.dreadweaver.SK_Dreadweaver")), 0);
				PropertyInfo property = typeof(NetworkObject).GetProperty("GlobalObjectIdHash", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null && property.CanWrite)
				{
					property.SetValue(val, num);
					return;
				}
				FieldInfo fieldInfo = typeof(NetworkObject).GetField("GlobalObjectIdHash", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? typeof(NetworkObject).GetField("<GlobalObjectIdHash>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
				if (fieldInfo != null)
				{
					fieldInfo.SetValue(val, num);
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Could not assign NetworkObject hash for Dreadweaver: " + ex.Message));
			}
		}

		private static void DumpBundleAssets()
		{
			if (!((Object)(object)ModAssets == (Object)null))
			{
				string[] allAssetNames = ModAssets.GetAllAssetNames();
				foreach (string text in allAssetNames)
				{
					Log.LogError((object)("  - " + text));
				}
			}
		}

		private static void TrySetTag(GameObject gameObject, string tag)
		{
			try
			{
				gameObject.tag = tag;
			}
			catch
			{
			}
		}

		private static void TrySetLayer(GameObject gameObject, string layerName)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			int num = LayerMask.NameToLayer(layerName);
			if (num < 0)
			{
				num = ResolveLayerFallback(layerName);
			}
			if (num >= 0 && num <= 31)
			{
				gameObject.layer = num;
				return;
			}
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogWarning((object)$"[Dreadweaver] Layer '{layerName}' unresolved; '{((Object)gameObject).name}' stays on layer {gameObject.layer}.");
			}
		}

		private static int ResolveLayerFallback(string layerName)
		{
			if (string.Equals(layerName, "ScanNode", StringComparison.OrdinalIgnoreCase))
			{
				return 22;
			}
			if (string.Equals(layerName, "Enemies", StringComparison.OrdinalIgnoreCase))
			{
				return 19;
			}
			return -1;
		}

		private static void EnsureHierarchyActive(Transform child, Transform stopAt)
		{
			Transform val = child;
			while ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(true);
				if (!((Object)(object)val == (Object)(object)stopAt))
				{
					val = val.parent;
					continue;
				}
				break;
			}
		}
	}
	internal static class PluginInfo
	{
		public const string PLUGIN_GUID = "y4ngz.lethalcompany.dreadweaver";

		public const string PLUGIN_NAME = "Y4NGZ Dreadweaver";

		public const string PLUGIN_VERSION = "0.1.0";
	}
}
namespace Y4NGZDreadweaver.AI
{
	public sealed class DreadweaverAI : EnemyAI
	{
		private struct AttackProfile
		{
			public readonly int AnimationCode;

			public readonly float StrikeTimeSeconds;

			public readonly float RecoverySeconds;

			public readonly float RangeMultiplier;

			public readonly float ArcMultiplier;

			public readonly float SelectionWeight;

			public AttackProfile(int animationCode, float strikeTimeSeconds, float recoverySeconds, float rangeMultiplier, float arcMultiplier, float selectionWeight)
			{
				AnimationCode = animationCode;
				StrikeTimeSeconds = strikeTimeSeconds;
				RecoverySeconds = recoverySeconds;
				RangeMultiplier = rangeMultiplier;
				ArcMultiplier = arcMultiplier;
				SelectionWeight = selectionWeight;
			}
		}

		private struct FlickerLight
		{
			public Light Light;

			public bool Enabled;

			public float Intensity;
		}

		private enum SightingStage
		{
			Long,
			Medium,
			Short
		}

		private enum SightingPresentation
		{
			HallwayEnd,
			CornerReveal,
			DeadEndBehind
		}

		private enum AttackEngageMode
		{
			WalkThenRun,
			RunImmediately,
			CrawlThenRun
		}

		private sealed class CamoShellRenderer
		{
			public Renderer Renderer;

			public Material[] Materials;
		}

		private sealed class LightFlickerState
		{
			public Light Light;

			public bool Enabled;

			public float Intensity;
		}

		public const int StateHiddenAcquireTarget = 0;

		public const int StateHiddenFindWatch = 1;

		public const int StateSightingVisible = 2;

		public const int StateHiddenBetweenSightings = 3;

		public const int StateHiddenPreAttackDelay = 4;

		public const int StateAttackSetup = 5;

		public const int StateCrawlAdvance = 6;

		public const int StatePursuit = 7;

		public const int StateAttackVanishReposition = 8;

		public const int StateHit = 9;

		public const int StateDead = 10;

		private const ulong NoTargetClientId = ulong.MaxValue;

		private const float EyeHeight = 1.65f;

		private const float RevealUnseenHalfAngle = 35f;

		private const float DirectRevealHalfAngle = 12f;

		private const float AttackRevealUnseenHalfAngle = 45f;

		private const float ShortCornerMaxPathDistance = 16f;

		private const float ShortApproachVanishDistance = 2.4f;

		private const float DirectRevealDelaySeconds = 0.75f;

		private const float ReengageCamoPreviewSeconds = 0.72f;

		private const int MaxRapidReengagements = 3;

		private const float WatchSearchRelaxSeconds = 5f;

		private const float LongSearchRelaxSeconds = 8f;

		private const float RevealSearchTimeoutSeconds = 12f;

		private const float SightingSeenCloseThreshold = 1.1f;

		private const float WatchLosGraceSeconds = 2.5f;

		private const float MinDistanceFromLastVanish = 8f;

		private const float VisibilityResyncInterval = 6f;

		private const float PresentationSyncInterval = 0.08f;

		private const float PresentationYawThreshold = 1.25f;

		private const float RevealFacingLockSeconds = 0.8f;

		private const float RevealReadableFraction = 0.72f;

		private const float VanishColliderDisableFraction = 0.6f;

		private const float ReplicatedFacingTurnSpeed = 540f;

		private const float AnimationCrossFadeSeconds = 0.18f;

		private const float SightingMinimumStareSeconds = 0.85f;

		private const float UnseenPresentationTimeoutSeconds = 6f;

		private const float CornerPresentationMaxPathDistance = 23f;

		private const float DeadEndBehindMaxPathDistance = 26f;

		private const float RequiredSightingIntervalMinSeconds = 45f;

		private const float RequiredSightingIntervalFallbackMaxSeconds = 65f;

		private const float RetrySightingIntervalMinSeconds = 15f;

		private const float RetrySightingIntervalFallbackMaxSeconds = 30f;

		private const float AttackReadyDelayMinSeconds = 15f;

		private const float AttackReadyDelayMaxSeconds = 30f;

		private const float ExitDodgeSeconds = 0.42f;

		private const float ExitDodgeVisibleSeconds = 0.16f;

		private const float ExitDodgeCamoSeconds = 0.24f;

		private const float LongSightingDodgeChance = 0.12f;

		private const float MediumSightingDodgeChance = 0.06f;

		private const float ExitWalkBackSeconds = 0.82f;

		private const float ExitWalkBackDistance = 4.75f;

		private const float ExitDodgeDistance = 6.5f;

		private const float PlacementClearanceRadius = 0.82f;

		private const float PlacementClearanceHeight = 2.45f;

		private const float DefaultAttackDamageDelay = 0.48f;

		private const float AttackStuckRecoverySeconds = 7f;

		private const float AttackSoftPathRepairSeconds = 1.6f;

		private const float AttackPathRepairCooldownSeconds = 1.4f;

		private const float AttackProgressCheckIntervalSeconds = 0.35f;

		private const float AttackProgressMinDistance = 0.18f;

		private const float AttackWalkIntroSeconds = 3f;

		private const float StalkLightFlickerInitialMinSeconds = 12f;

		private const float StalkLightFlickerInitialMaxSeconds = 24f;

		private const float StalkLightFlickerDurationSeconds = 1.15f;

		private const int StalkLightFlickerBudgetMin = 2;

		private const int StalkLightFlickerBudgetMax = 3;

		private const int MaxStalkFlickerLights = 10;

		private const int MaxStalkFlickerAnimators = 8;

		private const int MaxPoweredLightSightingCandidates = 16;

		private const float PoweredLightCandidateSearchPadding = 8f;

		private const float PoweredLightCandidateSampleRadius = 4.5f;

		private const float PoweredLightAffinityRadius = 9f;

		private const float PoweredLightAffinityMaxScore = 4.75f;

		private const float StalkDoorSlamInitialMinSeconds = 24f;

		private const float StalkDoorSlamInitialMaxSeconds = 40f;

		private const float DoorSlamOpenSeconds = 0.2f;

		private const float DoorSlamClosedSeconds = 0.16f;

		private const int DoorSlamCycles = 3;

		private const float DamageStunFreezeSeconds = 1f;

		private const float FootstepPhaseOffset = 0.08f;

		private const int FootstepsPerLocomotionCycle = 2;

		private const string CamoShellName = "_DreadweaverCamoShell";

		private const int AnimIdle1 = 0;

		private const int AnimIdle2 = 1;

		private const int AnimIdle3 = 2;

		private const int AnimIdle4 = 3;

		private const int AnimWalk1 = 4;

		private const int AnimWalk2 = 5;

		private const int AnimWalkBack = 6;

		private const int AnimWalkLeft = 7;

		private const int AnimWalkLeft2 = 8;

		private const int AnimWalkRight = 9;

		private const int AnimRun = 10;

		private const int AnimCrawl = 11;

		private const int AnimDodgeLeft = 12;

		private const int AnimDodgeRight = 13;

		private const int AnimDodgeForward = 14;

		private const int AnimDodgeBackward = 15;

		private const int AnimTurnLeft = 16;

		private const int AnimTurnRight = 17;

		private const int AnimWeaveFear = 18;

		private const int AnimAttackBase = 20;

		private const int AnimTakingDamage1 = 40;

		private const int AnimTakingDamage2 = 41;

		private const int AnimDeath1 = 50;

		private const int AnimDeath2 = 51;

		private static readonly AttackProfile[] AttackProfiles = new AttackProfile[9]
		{
			new AttackProfile(21, 0.37f, 0.83f, 0.92f, 0.92f, 1.15f),
			new AttackProfile(22, 0.48f, 1.5f, 1f, 1f, 1f),
			new AttackProfile(23, 0.43f, 1.2f, 0.96f, 1.06f, 1.1f),
			new AttackProfile(24, 0.53f, 1.83f, 1f, 1f, 1f),
			new AttackProfile(25, 0.53f, 1.83f, 1f, 1f, 1f),
			new AttackProfile(26, 0.65f, 2.67f, 1.08f, 0.9f, 0.7f),
			new AttackProfile(27, 0.6f, 2.43f, 1.05f, 0.95f, 0.8f),
			new AttackProfile(28, 0.58f, 2.43f, 1.05f, 1f, 0.8f),
			new AttackProfile(29, 0.55f, 2.13f, 1f, 1.08f, 0.9f)
		};

		[Header("Dreadweaver anchors")]
		public Transform attackOrigin;

		public Animator visualAnimator;

		[Header("Dreadweaver search")]
		public AISearchRoutine attackRecoverySearch = new AISearchRoutine();

		[Header("Dreadweaver audio")]
		public AudioClip[] spotClips = (AudioClip[])(object)new AudioClip[0];

		public AudioClip[] footstepClips = (AudioClip[])(object)new AudioClip[0];

		public AudioClip initialAttackClip;

		public AudioClip spottedClip;

		public AudioClip vanishClip;

		public AudioClip decloakClip;

		public AudioClip attackClip;

		public AudioClip hitClip;

		public AudioClip deathClip;

		private readonly RaycastHit[] _lineOfSightHits = (RaycastHit[])(object)new RaycastHit[48];

		private readonly Collider[] _placementColliders = (Collider[])(object)new Collider[24];

		private readonly List<CamoShellRenderer> _camoShells = new List<CamoShellRenderer>();

		private readonly List<LightFlickerState> _activeLightFlickerStates = new List<LightFlickerState>();

		private readonly NetworkVariable<int> _networkState = new NetworkVariable<int>(0, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<ulong> _networkTargetClientId = new NetworkVariable<ulong>(ulong.MaxValue, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<int> _networkStage = new NetworkVariable<int>(0, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<int> _networkPresentation = new NetworkVariable<int>(0, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<int> _networkAnimationCode = new NetworkVariable<int>(0, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<float> _networkAnimationNormalizedTime = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<bool> _networkVisible = new NetworkVariable<bool>(true, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<int> _networkVisibilitySequence = new NetworkVariable<int>(0, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<float> _networkFacingYaw = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<int> _networkRevealSequence = new NetworkVariable<int>(0, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<Vector3> _networkRevealPosition = new NetworkVariable<Vector3>(Vector3.zero, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<float> _networkFacingLockDuration = new NetworkVariable<float>(0.8f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<float> _networkPresentationReadyDelay = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<Vector3> _networkModelScale = new NetworkVariable<Vector3>(Vector3.one, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<float> _networkMovementSpeed = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<float> _networkLocomotionPlayback = new NetworkVariable<float>(1f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<bool> _networkSpotlightActive = new NetworkVariable<bool>(false, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<float> _networkSpotlightIntensity = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<float> _networkSpotlightAngle = new NetworkVariable<float>(42f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<float> _networkSpotlightRange = new NetworkVariable<float>(14f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<float> _networkSpotlightHeight = new NetworkVariable<float>(5f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private readonly NetworkVariable<Vector3> _networkSpotlightColor = new NetworkVariable<Vector3>(Vector3.one, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		private Renderer[] _bodyRenderers = (Renderer[])(object)new Renderer[0];

		private bool[] _bodyRendererDefaults = new bool[0];

		private Collider[] _bodyColliders = (Collider[])(object)new Collider[0];

		private bool[] _bodyColliderDefaults = new bool[0];

		private bool _visualsCaptured;

		private bool _camoShellsCreated;

		private bool _usingBundledCamoMaterial;

		private bool _loggedCamoFallback;

		private bool _logicalVisible = true;

		private bool _renderersShown = true;

		private int _visSeq;

		private int _appliedVisSeq = -1;

		private Coroutine _flickerRoutine;

		private Coroutine _camoPreviewRoutine;

		private Coroutine _localLightFlickerRoutine;

		private float _nextVisibilityResyncTime;

		private float _presentationReadyAt;

		private float _nextPresentationSyncTime;

		private float _lastPublishedFacingYaw;

		private float _lastPublishedMovementSpeed = -1f;

		private float _lastPublishedLocomotionPlayback = -1f;

		private int _clientAppliedRevealSequence;

		private float _clientFacingLockUntil;

		private SightingStage _stage;

		private SightingPresentation _pendingPresentation;

		private ulong _targetClientId = ulong.MaxValue;

		private ulong _lastKilledTargetClientId = ulong.MaxValue;

		private ulong _lastHitByClientId = ulong.MaxValue;

		private float _phaseEnteredAt;

		private float _nextActionTime;

		private bool _hasPendingWatchPosition;

		private float _watchRevealDeadline;

		private float _sightingFirstSeenAt = -1f;

		private float _sightingSeenDistance;

		private float _losLostSince = -1f;

		private Vector3 _lastVanishPosition;

		private bool _hasLastVanishPosition;

		private Coroutine _sightingExitRoutine;

		private bool _isEndingSighting;

		private Coroutine _stalkDoorSlamRoutine;

		private DoorLock _stalkDoorSlamDoor;

		private float _nextStalkLightFlickerTime;

		private float _nextStalkDoorSlamTime;

		private int _remainingStalkLightFlickers;

		private Vector3 _lastAttackRevealPosition;

		private bool _hasLastAttackRevealPosition;

		private AttackEngageMode _attackEngageMode = AttackEngageMode.CrawlThenRun;

		private int _attackAdvanceAnimation = 11;

		private float _attackAdvanceEndTime;

		private float _nextAttackTime;

		private float _lostSightTimer;

		private float _repositionRelaxAt;

		private Vector3 _lastKnownAttackTargetPosition;

		private Vector3 _lastAttackProgressPosition;

		private float _lastAttackProgressDistance;

		private float _attackStuckTimer;

		private float _nextAttackProgressCheckTime;

		private float _nextAttackPathRepairTime;

		private Coroutine _attackRoutine;

		private Coroutine _reengageCueRoutine;

		private bool _isAttackAnimating;

		private bool _isHitStaggering;

		private AttackProfile _activeAttackProfile;

		private bool _resolvePostTargetDownAfterSwing;

		private float _attackMovementReadyAt;

		private bool _pursuitSpotlightProfileApplied;

		private int _rapidReengagementCount;

		private float _nextLocalFearTime;

		private float _lastLocalMovementAnimTime;

		private float _animationLockUntil;

		private float _damageStunUntil;

		private float _preDamageStunAnimatorSpeed = 1f;

		private string _currentAnimationName;

		private int _currentAnimationCode = int.MinValue;

		private float _currentAnimationNormalizedTime;

		private bool _damageStunFrozen;

		private bool _locomotionMoving;

		private int _footstepAnimatorStateHash;

		private int _footstepTick = int.MinValue;

		private float _lastFootstepNormalizedTime;

		private int _lastFootstepClipIndex = -1;

		private bool _hasPlayedInitialAttackJumpscare;

		private static AudioClip _directionalCamoCue;

		private DreadweaverSpotlight _spotlight;

		private bool _spotlightActive;

		private float _spotlightIntensity;

		private float _spotlightAngle = 42f;

		private float _spotlightRange = 14f;

		private float _spotlightHeight = 5f;

		private Vector3 _spotlightColor = Vector3.one;

		private Coroutine _flashlightHarassRoutine;

		private readonly List<FlickerLight> _flashlightHarassLights = new List<FlickerLight>();

		private float _nextFlashlightHarassTime;

		private float StalkMoveSpeed => Mathf.Clamp(Plugin.ModConfig?.StalkMoveSpeed.Value ?? 1.5f, 0.5f, 4f);

		private float CrawlSpeed => Mathf.Clamp(Plugin.ModConfig?.CrawlSpeed.Value ?? 2.1f, 0.8f, 4f);

		private float AttackWalkSpeed => Mathf.Clamp(Mathf.Max(StalkMoveSpeed, CrawlSpeed * 0.85f), 1.25f, 3.2f);

		private float AttackSpeed => Mathf.Clamp(Plugin.ModConfig?.AttackSpeed.Value ?? 5.15f, 2f, 9f);

		private float TurnSpeed => 420f;

		private float Acceleration => 18f;

		private float SpotHalfAngle => 25f;

		private float CreatureSightRange => 60f;

		private float SightingIntervalMin => Mathf.Clamp(Plugin.ModConfig?.SightingIntervalMinSeconds.Value ?? 45f, 8f, 120f);

		private float SightingIntervalMax => ResolveIntervalMax(Plugin.ModConfig?.SightingIntervalMaxSeconds.Value ?? 65f, SightingIntervalMin, 65f, 150f);

		private float SightingRetryMin => 15f;

		private float SightingRetryMax => 30f;

		private float SightingTimeoutSeconds => 12f;

		private float StalkLightFlickerRadius => 18f;

		private float StalkLightFlickerIntervalMin => 40f;

		private float StalkLightFlickerIntervalMax => 70f;

		private float StalkDoorSlamRadius => 14f;

		private float StalkDoorSlamIntervalMin => 35f;

		private float StalkDoorSlamIntervalMax => 70f;

		private float AttackDelayMin => Mathf.Clamp(Plugin.ModConfig?.AttackDelayMinSeconds.Value ?? 15f, 5f, 60f);

		private float AttackDelayMax => Mathf.Max(AttackDelayMin, Mathf.Clamp(Plugin.ModConfig?.AttackDelayMaxSeconds.Value ?? 30f, AttackDelayMin, 90f));

		private float AttackRevealMin => 8f;

		private float AttackRevealMax => 16f;

		private float CrawlAdvanceSeconds => 3f;

		private float AttackRange => 2.35f;

		private float AttackCooldown => Mathf.Clamp(Plugin.ModConfig?.AttackCooldown.Value ?? 1.8f, 0.5f, 6f);

		private float AttackDamageDelay => 0.48f;

		private float AttackHitHalfAngle => 60f;

		private int AttackDamage => Mathf.Clamp(Plugin.ModConfig?.AttackDamage.Value ?? 40, 1, 100);

		private float AttackLoseDistance => 48f;

		private float AttackLostSightGraceSeconds => 12f;

		private float PursuitRepositionCooldownMin => 2f;

		private float PursuitRepositionCooldownMax => 5f;

		private float PursuitRepositionMinDistance => 10f;

		private float ChainAttackRadius => 13f;

		private float VanishFlickerSeconds => 0.65f;

		private float DecloakFlickerSeconds => 0.55f;

		private bool DebugLogs => Plugin.ModConfig?.DebugLogs.Value ?? false;

		private bool MatchAnimationToMovement => true;

		private float AuthoredWalkSpeed => 1.9f;

		private float AuthoredCrawlSpeed => 1.9f;

		private float AuthoredRunSpeed => 3.6f;

		private bool CreatureSpotlightEnabled => Plugin.ModConfig?.CreatureSpotlightEnabled.Value ?? true;

		private bool FlashlightHarassEnabled => Plugin.ModConfig?.FlashlightHarassEnabled.Value ?? true;

		private bool CanSendRpc
		{
			get
			{
				if ((Object)(object)((NetworkBehaviour)this).NetworkObject != (Object)null)
				{
					return ((NetworkBehaviour)this).NetworkObject.IsSpawned;
				}
				return false;
			}
		}

		private static float ResolveIntervalMax(float configuredValue, float min, float fallbackMax, float hardMax)
		{
			if (configuredValue < min + 0.1f)
			{
				return Mathf.Max(min + 1f, fallbackMax);
			}
			return Mathf.Max(min, Mathf.Clamp(configuredValue, min, hardMax));
		}

		public override void Awake()
		{
			try
			{
				((EnemyAI)this).Awake();
				ResolveReferences();
				ConfigureAttackSearchDefaults();
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"[DreadweaverAI] Awake failed: {arg}");
				}
			}
		}

		public override void OnNetworkSpawn()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			((NetworkBehaviour)this).OnNetworkSpawn();
			_clientAppliedRevealSequence = -1;
			if (((NetworkBehaviour)this).IsServer)
			{
				_networkModelScale.Value = ((Component)this).transform.localScale;
			}
			else
			{
				ApplyNetworkSnapshotLocal(force: true);
			}
		}

		public override void Start()
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				((EnemyAI)this).Start();
				Plugin.EnsureScanNode(((Component)this).gameObject);
				ResolveReferences();
				ConfigureAttackSearchDefaults();
				CaptureVisuals();
				base.enemyHP = Plugin.ModConfig?.Health.Value ?? 5;
				ConfigureAgent(StalkMoveSpeed);
				StopAgent();
				SetStateLocal(0);
				PlayAnimationLocal(0, 0.18f, 0f);
				_hasPlayedInitialAttackJumpscare = false;
				ResetFootstepTracking();
				if (((NetworkBehaviour)this).IsServer)
				{
					RepairFacilityAINodes();
					PublishAuthoritativePresentationServer(force: true);
					VanishServer(playCue: false);
					_nextActionTime = Time.time + Random.Range(2f, 4f);
				}
				else if (((NetworkBehaviour)this).IsSpawned)
				{
					ApplyNetworkSnapshotLocal(force: true);
				}
				if (DebugLogs)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)$"[DreadweaverAI] Spawned #{base.thisEnemyIndex} at {((Component)this).transform.position}.");
					}
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)$"[DreadweaverAI] Start failed: {arg}");
				}
			}
		}

		public override void Update()
		{
			try
			{
				((EnemyAI)this).Update();
				if (base.isEnemyDead)
				{
					return;
				}
				ResolveReferences();
				ApplyNetworkSnapshotLocal();
				ApplyReplicatedFacingLocal();
				if (ApplyDamageStunFreeze())
				{
					return;
				}
				TickLocalFear();
				TickAnimatorPlaybackSpeed();
				TickLocalFootsteps();
				if (!((NetworkBehaviour)this).IsServer || (Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.allPlayersDead)
				{
					return;
				}
				if (Time.time >= _nextVisibilityResyncTime)
				{
					_nextVisibilityResyncTime = Time.time + 6f;
					if (CanSendRpc)
					{
						ResyncVisibilityClientRpc(_logicalVisible, _visSeq);
					}
				}
				if (!_isHitStaggering)
				{
					TickStalkingEnvironmentScares();
					switch (base.currentBehaviourStateIndex)
					{
					case 0:
						TickHiddenAcquireTarget();
						break;
					case 1:
						TickHiddenFindWatch();
						break;
					case 2:
						TickSightingVisible(Time.deltaTime);
						break;
					case 3:
						TickHiddenWait(1);
						break;
					case 4:
						TickHiddenWait(5);
						break;
					case 5:
						TickAttackSetup();
						break;
					case 6:
						TickCrawlAdvance(Time.deltaTime);
						break;
					case 7:
						TickPursuit(Time.deltaTime);
						break;
					case 8:
						TickAttackVanishReposition();
						break;
					}
					TickAuthoritativeLocomotionAnimation();
					PublishAuthoritativePresentationServer();
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"[DreadweaverAI] Update failed: {arg}");
				}
			}
		}

		public override void DoAIInterval()
		{
			try
			{
				((EnemyAI)this).DoAIInterval();
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"[DreadweaverAI] DoAIInterval failed: {arg}");
				}
			}
		}

		public override void HitEnemy(int force = 1, PlayerControllerB playerWhoHit = null, bool playHitSFX = false, int hitID = -1)
		{
			try
			{
				((EnemyAI)this).HitEnemy(force, playerWhoHit, playHitSFX, hitID);
				if (base.isEnemyDead)
				{
					return;
				}
				BeginDamageStunFreeze();
				if (!((NetworkBehaviour)this).IsServer)
				{
					return;
				}
				base.enemyHP -= Mathf.Max(1, force);
				if (base.enemyHP <= 0)
				{
					DieFromDamage();
					return;
				}
				_lastHitByClientId = (((Object)(object)playerWhoHit != (Object)null) ? playerWhoHit.actualClientId : ulong.MaxValue);
				if (!_isHitStaggering)
				{
					((MonoBehaviour)this).StartCoroutine(HitStaggerRoutine());
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"[DreadweaverAI] HitEnemy failed: {arg}");
				}
			}
		}

		public override void KillEnemy(bool destroy = false)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				StopManagedRoutines();
				if (_flickerRoutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(_flickerRoutine);
					_flickerRoutine = null;
				}
				if (_camoPreviewRoutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(_camoPreviewRoutine);
					_camoPreviewRoutine = null;
				}
				StopLocalLightFlicker();
				StopFlashlightHarass();
				_spotlightActive = false;
				ApplyCreatureSpotlight(active: false, 0f, 0f, 0f, 0f, Vector3.zero);
				_logicalVisible = true;
				_isEndingSighting = false;
				SetCollidersEnabled(enabled: true);
				SetCamoShellsShown(shown: false);
				SetRenderersShown(shown: true);
				ClearDamageStunFreeze();
				StopAgent();
				((EnemyAI)this).KillEnemy(destroy);
				base.isEnemyDead = true;
				SetStateLocal(10);
				PlayAnimationLocal((Random.value < 0.5f) ? 50 : 51, 0.08f, 0f);
				if ((Object)(object)deathClip != (Object)null && (Object)(object)base.creatureVoice != (Object)null)
				{
					base.creatureVoice.PlayOneShot(deathClip, 1f);
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"[DreadweaverAI] KillEnemy failed: {arg}");
				}
			}
		}

		private void TickHiddenAcquireTarget()
		{
			if (!(Time.time < _nextActionTime))
			{
				_nextActionTime = Time.time + 1.5f;
				PlayerControllerB val = ChooseFixationTarget();
				if (!((Object)(object)val == (Object)null))
				{
					SetFixationTarget(val, "new stalking target");
					_stage = SightingStage.Long;
					EnterPhase(1);
				}
			}
		}

		private void TickHiddenWait(int nextState)
		{
			if ((Object)(object)RequireStalkTarget() == (Object)null)
			{
				RestartStalkCycle("target lost while hidden");
			}
			else if (!(Time.time < _nextActionTime))
			{
				EnterPhase(nextState);
			}
		}

		private void TickHiddenFindWatch()
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = RequireStalkTarget();
			if ((Object)(object)val == (Object)null)
			{
				RestartStalkCycle("target lost while finding watch position");
			}
			else if (!_hasPendingWatchPosition)
			{
				if (Time.time < _nextActionTime)
				{
					return;
				}
				_nextActionTime = Time.time + 0.65f;
				if (!TryFindSightingPosition(val, _stage, out var position))
				{
					if (Time.time - _phaseEnteredAt > 12f)
					{
						RestartStalkCycle("no stalking presentation found");
					}
				}
				else
				{
					TeleportFacing(position, GetPlayerFocusPoint(val));
					_hasPendingWatchPosition = true;
					_watchRevealDeadline = Time.time + 0.75f;
				}
			}
			else if (!ValidateWatchPosition(val, _stage))
			{
				_hasPendingWatchPosition = false;
			}
			else
			{
				if (AnyPlayerWouldSeePosition(GetCreatureFocusPoint(), 12f) && Time.time < _watchRevealDeadline)
				{
					return;
				}
				TeleportFacing(((Component)this).transform.position, GetPlayerFocusPoint(val));
				RevealServer(Mathf.Max(0.08f, DecloakFlickerSeconds * 0.75f));
				PlayStalkingRevealSoundServer(val);
				PlayAnimationServer(ChooseSightingIntroAnimation(), 0.2f, GetSightingIntroNormalizedTime());
				EnterPhase(2);
				if (DebugLogs)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)$"[DreadweaverAI] {_stage}/{_pendingPresentation} sighting revealed at {((Component)this).transform.position}.");
					}
				}
			}
		}

		private bool ValidateWatchPosition(PlayerControllerB target, SightingStage stage)
		{
			//IL_0015: 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_0052: 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_0091: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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)
			GetStageParameters(stage, out var min, out var max, out var _, out var panic);
			float num = Vector3.Distance(((Component)this).transform.position, ((Component)target).transform.position);
			float radius = ((_pendingPresentation == SightingPresentation.HallwayEnd && stage != SightingStage.Short) ? panic : Mathf.Max(2.6f, 2.4f));
			if (TooCloseToAnyPlayer(((Component)this).transform.position, radius))
			{
				return false;
			}
			if (_pendingPresentation == SightingPresentation.CornerReveal)
			{
				if (num <= Mathf.Max(max + 10f, 13f))
				{
					return HasShortCompletePath(((Component)this).transform.position, ((Component)target).transform.position, 23f);
				}
				return false;
			}
			if (_pendingPresentation == SightingPresentation.DeadEndBehind)
			{
				if (num >= 3.5f && num <= Mathf.Max(max + 12f, 18f))
				{
					return HasShortCompletePath(((Component)this).transform.position, ((Component)target).transform.position, 26f);
				}
				return false;
			}
			if (num < min * 0.6f || num > max * 1.35f)
			{
				return false;
			}
			return HasClearLineOfSight(GetCreatureFocusPoint(), GetPlayerFocusPoint(target), ((Component)target).transform);
		}

		private void TickSightingVisible(float deltaTime)
		{
			//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_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = RequireStalkTarget();
			if ((Object)(object)val == (Object)null)
			{
				RestartStalkCycle("target lost while visible");
				return;
			}
			StopAgent();
			FaceTargetForStalking(val);
			if (_isEndingSighting)
			{
				return;
			}
			GetStageParameters(_stage, out var min, out var max, out var hold, out var panic);
			hold = Mathf.Max(0.85f, hold);
			float num