using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dissonance.Integrations.Unity_NFGO;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Microsoft.ML.OnnxRuntime;
using Microsoft.ML.OnnxRuntime.Tensors;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.UI;

[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("WormtownAI")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+6ee958d45c268a70f4db457289d12410c4201df6")]
[assembly: AssemblyProduct("WormtownAI")]
[assembly: AssemblyTitle("WormtownAI")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 WormtownAI
{
	public class AiWorm : MonoBehaviour
	{
		public ulong requester_client_id;

		public int owner_slot;

		public AiWormDifficulty difficulty;

		public PlayerCosmeticData cosmetic_data;

		public bool has_cosmetic_data;
	}
	[HarmonyPatch]
	public static class AiWormCosmetics
	{
		private struct CosmeticBankState
		{
			public Dictionary<ulong, PlayerCosmeticData> bank;

			public ulong owner_id;

			public bool had_original;

			public PlayerCosmeticData original;
		}

		private const string GRAY_HEX = "7A7A7A";

		private const string DARK_GRAY_HEX = "727272";

		public static PlayerCosmeticData Create(PlayerCosmeticData source)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			PlayerCosmeticData result = source;
			byte[] bytes = Encoding.UTF8.GetBytes("7A7A7A");
			byte[] bytes2 = Encoding.UTF8.GetBytes("727272");
			result.worm_Hat_Model_Index = 0;
			result.worm_Horn_Model_Index = 0;
			result.worm_Eyes_Model_Index = 0;
			result.worm_Teeth_Model_Index = 2;
			result.worm_Head_Model_Index = 0;
			result.worm_Head_Color_Primary_Index = 0;
			result.worm_Head_Color_Secondary_Index = 0;
			result.worm_Head_Color_Primary_Hex = bytes;
			result.worm_Head_Color_Secondary_Hex = bytes;
			result.worm_BodySegment_Model_Index_0 = 0;
			result.worm_BodySegment_Color_Primary_Index_0 = 0;
			result.worm_BodySegment_Color_Secondary_Index_0 = 0;
			result.worm_BodySegment_Color_Primary_Hex_0 = bytes2;
			result.worm_BodySegment_Color_Secondary_Hex_0 = bytes2;
			result.worm_BodySegment_Model_Index_1 = 0;
			result.worm_BodySegment_Color_Primary_Index_1 = 0;
			result.worm_BodySegment_Color_Secondary_Index_1 = 0;
			result.worm_BodySegment_Color_Primary_Hex_1 = bytes;
			result.worm_BodySegment_Color_Secondary_Hex_1 = bytes;
			result.worm_BodySegment_Model_Index_2 = 0;
			result.worm_BodySegment_Color_Primary_Index_2 = 0;
			result.worm_BodySegment_Color_Secondary_Index_2 = 0;
			result.worm_BodySegment_Color_Primary_Hex_2 = bytes2;
			result.worm_BodySegment_Color_Secondary_Hex_2 = bytes2;
			result.worm_BodySegment_Model_Index_3 = 0;
			result.worm_BodySegment_Color_Primary_Index_3 = 0;
			result.worm_BodySegment_Color_Secondary_Index_3 = 0;
			result.worm_BodySegment_Color_Primary_Hex_3 = bytes;
			result.worm_BodySegment_Color_Secondary_Hex_3 = bytes;
			result.worm_BodySegment_Model_Index_4 = 0;
			result.worm_BodySegment_Color_Primary_Index_4 = 0;
			result.worm_BodySegment_Color_Secondary_Index_4 = 0;
			result.worm_BodySegment_Color_Primary_Hex_4 = bytes2;
			result.worm_BodySegment_Color_Secondary_Hex_4 = bytes2;
			result.worm_BodySegment_Model_Index_5 = 0;
			result.worm_BodySegment_Color_Primary_Index_5 = 0;
			result.worm_BodySegment_Color_Secondary_Index_5 = 0;
			result.worm_BodySegment_Color_Primary_Hex_5 = bytes;
			result.worm_BodySegment_Color_Secondary_Hex_5 = bytes;
			result.worm_BodySegment_Model_Index_6 = 0;
			result.worm_BodySegment_Color_Primary_Index_6 = 0;
			result.worm_BodySegment_Color_Secondary_Index_6 = 0;
			result.worm_BodySegment_Color_Primary_Hex_6 = bytes2;
			result.worm_BodySegment_Color_Secondary_Hex_6 = bytes2;
			return result;
		}

		public static bool TryGet(InGameWormCosmeticBuilder builder, out PlayerCosmeticData data)
		{
			//IL_0001: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			data = default(PlayerCosmeticData);
			if (!LobbyAiState.IsLocalHost || (Object)(object)builder == (Object)null)
			{
				return false;
			}
			AiWorm componentInParent = ((Component)builder).GetComponentInParent<AiWorm>();
			if ((Object)(object)componentInParent == (Object)null || !componentInParent.has_cosmetic_data)
			{
				return false;
			}
			data = componentInParent.cosmetic_data;
			return true;
		}

		[HarmonyPatch(typeof(InGameWormCosmeticBuilder), "CreateCosmetics")]
		[HarmonyPrefix]
		public static void CreateCosmetics_Prefix(InGameWormCosmeticBuilder __instance)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (TryGet(__instance, out var data))
			{
				__instance.pcr = data;
			}
		}

		[HarmonyPatch(typeof(InGameWormCosmeticBuilder), "RequestPlayerCosmeticDataFromServer_ServerRPC")]
		[HarmonyPrefix]
		private static void RequestPlayerCosmeticData_Prefix(InGameWormCosmeticBuilder __instance, ulong __1, ref CosmeticBankState __state)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			__state = default(CosmeticBankState);
			if (TryGet(__instance, out var data) && !((Object)(object)GameManager.Singleton == (Object)null) && GameManager.Singleton.PlayerCosmeticDataBank != null)
			{
				Dictionary<ulong, PlayerCosmeticData> dictionary = (__state.bank = GameManager.Singleton.PlayerCosmeticDataBank);
				__state.owner_id = __1;
				__state.had_original = dictionary.TryGetValue(__1, out __state.original);
				dictionary[__1] = data;
			}
		}

		[HarmonyPatch(typeof(InGameWormCosmeticBuilder), "RequestPlayerCosmeticDataFromServer_ServerRPC")]
		[HarmonyFinalizer]
		private static Exception RequestPlayerCosmeticData_Finalizer(Exception __exception, CosmeticBankState __state)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (__state.bank == null)
			{
				return __exception;
			}
			if (__state.had_original)
			{
				__state.bank[__state.owner_id] = __state.original;
			}
			else
			{
				__state.bank.Remove(__state.owner_id);
			}
			return __exception;
		}
	}
	public enum AiWormDifficulty : byte
	{
		Garden,
		Snake,
		Bull
	}
	public static class AiWormDifficultyRules
	{
		public const float BULL_DESTRUCTION_CHANCE = 0.75f;

		public static AiWormDifficulty Clamp(int value)
		{
			return (AiWormDifficulty)Mathf.Clamp(value, 0, 2);
		}

		public static float Multiplier(AiWormDifficulty difficulty)
		{
			return difficulty switch
			{
				AiWormDifficulty.Snake => 1.3f, 
				AiWormDifficulty.Bull => 2f, 
				_ => 1f, 
			};
		}

		public static float BurrowMultiplier(AiWormDifficulty difficulty)
		{
			return difficulty switch
			{
				AiWormDifficulty.Snake => 2f, 
				AiWormDifficulty.Bull => 3f, 
				_ => 1f, 
			};
		}

		public static string DisplayName(AiWormDifficulty difficulty)
		{
			return difficulty switch
			{
				AiWormDifficulty.Snake => "Snake Worm", 
				AiWormDifficulty.Bull => "Bull Worm", 
				_ => "Garden Worm", 
			};
		}

		public static AiWormDifficulty For(Component component)
		{
			AiWorm aiWorm = (((Object)(object)component != (Object)null) ? component.GetComponentInParent<AiWorm>() : null);
			if (!((Object)(object)aiWorm != (Object)null))
			{
				return AiWormDifficulty.Garden;
			}
			return aiWorm.difficulty;
		}

		public static float Multiplier(Component component)
		{
			return Multiplier(For(component));
		}
	}
	[HarmonyPatch]
	public static class AiWormDifficultyPatches
	{
		private const float IMPACT_DEDUP_SECONDS = 0.25f;

		private const float EXPLOSION_RADIUS_MIN = 0.08f;

		private const float EXPLOSION_RADIUS_MID = 0.15f;

		private const float EXPLOSION_RADIUS_MAX = 0.25f;

		private const ulong NO_PLAYER_ID = 1000000uL;

		private static readonly Dictionary<WormMovement, Dictionary<int, float>> impact_retry_at = new Dictionary<WormMovement, Dictionary<int, float>>();

		[HarmonyPatch(typeof(WormAbilityManager), "GetCooldownMultiplier")]
		[HarmonyPostfix]
		public static void GetCooldownMultiplier_Postfix(WormAbilityManager __instance, ref float __result)
		{
			if (AiWormManager.IsActiveAiWorm((Component)(object)__instance))
			{
				__result *= AiWormDifficultyRules.Multiplier((Component)(object)__instance);
			}
		}

		[HarmonyPatch(typeof(WormMovement), "OnCollisionEnter")]
		[HarmonyPostfix]
		public static void OnCollisionEnter_Postfix(WormMovement __instance, Collision other)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Invalid comparison between Unknown and I4
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager singleton = NetworkManager.Singleton;
			AiWorm aiWorm = (((Object)(object)__instance != (Object)null) ? ((Component)__instance).GetComponentInParent<AiWorm>() : null);
			if ((Object)(object)singleton == (Object)null || !singleton.IsHost || !AiWormManager.IsActiveAiWorm((Component)(object)__instance) || (Object)(object)aiWorm == (Object)null || aiWorm.difficulty != AiWormDifficulty.Bull || other == null || (Object)(object)other.collider == (Object)null)
			{
				return;
			}
			WormMovementState wormMovementState = __instance.wormMovementState;
			if ((int)wormMovementState != 0 && (int)wormMovementState != 2)
			{
				return;
			}
			GameObject val = ResolveDestructible(other.collider);
			if ((Object)(object)val == (Object)null || !CanDestroy(val) || !BeginImpactRoll(__instance, val) || Random.value >= 0.75f)
			{
				return;
			}
			if (!TryFindContainedExplosion(other, val, out var explosion_pos, out var radius))
			{
				Plugin.log.LogWarning((object)("[worm] bull impact could not isolate " + ((Object)val).name + " for destruction"));
				return;
			}
			GameManager singleton2 = GameManager.Singleton;
			if (!((Object)(object)singleton2 == (Object)null))
			{
				singleton2.CreateExplosionAtPosition_ServerRPC(explosion_pos, radius, 1000000uL, 1000000uL, false);
				Plugin.log.LogInfo((object)("[worm] bull destroyed " + ((Object)val).name));
			}
		}

		public static void ForgetImpacts(WormMovement worm)
		{
			if ((Object)(object)worm != (Object)null)
			{
				impact_retry_at.Remove(worm);
			}
		}

		public static void ResetImpacts()
		{
			impact_retry_at.Clear();
		}

		private static GameObject ResolveDestructible(Collider collider)
		{
			Transform root = ((Component)collider).transform.root;
			if (((Component)root).CompareTag("Rock") || ((Component)root).CompareTag("Cactus"))
			{
				GameObject gameObject = ((Component)root).gameObject;
				if (!((Object)(object)gameObject.GetComponent<BrokenPrefabHolder>() != (Object)null))
				{
					return null;
				}
				return gameObject;
			}
			RootFinder componentInParent = ((Component)collider).GetComponentInParent<RootFinder>();
			GameObject val = (((Object)(object)componentInParent != (Object)null) ? ((Component)componentInParent).gameObject : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			if (val.CompareTag("CollapsibleBuilding") && (Object)(object)val.GetComponent<CollapsibleBuilding>() != (Object)null)
			{
				return val;
			}
			if (val.CompareTag("DestructibleTrain") && (Object)(object)val.GetComponent<DestructibleTrain>() != (Object)null)
			{
				return val;
			}
			return null;
		}

		private static bool CanDestroy(GameObject target)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			CollapsibleBuilding component = target.GetComponent<CollapsibleBuilding>();
			if ((Object)(object)component != (Object)null)
			{
				return !component.GetHasCollapsed();
			}
			DestructibleTrain component2 = target.GetComponent<DestructibleTrain>();
			if ((Object)(object)component2 != (Object)null)
			{
				return !component2.GetDestroyedState();
			}
			return target.transform.position.y < 5000f;
		}

		private static bool BeginImpactRoll(WormMovement worm, GameObject target)
		{
			if (!impact_retry_at.TryGetValue(worm, out var value))
			{
				value = new Dictionary<int, float>();
				impact_retry_at[worm] = value;
			}
			int instanceID = ((Object)target).GetInstanceID();
			if (value.TryGetValue(instanceID, out var value2) && Time.time < value2)
			{
				return false;
			}
			value[instanceID] = Time.time + 0.25f;
			return true;
		}

		private static bool TryFindContainedExplosion(Collision collision, GameObject target, out Vector3 explosion_pos, out float radius)
		{
			//IL_0025: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			Collider collider = collision.collider;
			Vector3 val;
			if (collision.contactCount <= 0)
			{
				val = collider.ClosestPoint(collision.transform.position);
			}
			else
			{
				ContactPoint contact = collision.GetContact(0);
				val = ((ContactPoint)(ref contact)).point;
			}
			Vector3 val2 = val;
			Bounds bounds = collider.bounds;
			Vector3 val3 = ((Bounds)(ref bounds)).center - val2;
			Vector3 val4 = ((((Vector3)(ref val3)).sqrMagnitude > 0.0001f) ? ((Vector3)(ref val3)).normalized : Vector3.zero);
			Vector3[] obj = new Vector3[4]
			{
				val2 + val4 * 0.2f,
				val2 + val4 * 0.4f,
				default(Vector3),
				default(Vector3)
			};
			bounds = collider.bounds;
			obj[2] = collider.ClosestPoint(((Bounds)(ref bounds)).center);
			bounds = collider.bounds;
			obj[3] = ((Bounds)(ref bounds)).center;
			Vector3[] array = (Vector3[])(object)obj;
			float[] array2 = new float[3] { 0.08f, 0.15f, 0.25f };
			foreach (float num in array2)
			{
				Vector3[] array3 = array;
				foreach (Vector3 val5 in array3)
				{
					if (IsContainedTargetSphere(val5, num, target))
					{
						explosion_pos = val5;
						radius = num;
						return true;
					}
				}
			}
			explosion_pos = Vector3.zero;
			radius = 0f;
			return false;
		}

		private static bool IsContainedTargetSphere(Vector3 position, float radius, GameObject target)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			bool result = false;
			Collider[] array = Physics.OverlapSphere(position, radius, -1, (QueryTriggerInteraction)1);
			foreach (Collider val in array)
			{
				if (((Component)val).CompareTag("Player") || ((Component)val).CompareTag("WormPlayer") || ((Component)val).CompareTag("PickUp"))
				{
					return false;
				}
				GameObject val2 = ResolveDestructible(val);
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2 != (Object)(object)target)
				{
					return false;
				}
				if ((Object)(object)val2 == (Object)(object)target)
				{
					result = true;
				}
			}
			return result;
		}
	}
	[HarmonyPatch]
	public static class AiWormLoadoutPatches
	{
		[HarmonyPatch(typeof(WormAbilityManager), "Start", new Type[] { })]
		[HarmonyPostfix]
		public static void Start_Postfix(WormAbilityManager __instance)
		{
			if (!AiWormManager.IsAiWorm((Component)(object)__instance))
			{
				return;
			}
			try
			{
				if (LobbyAiState.ApplyAiLoadout(__instance))
				{
					Plugin.log.LogInfo((object)"[ai-toggle] applied required powers to spawned ai worm");
				}
				else
				{
					Plugin.log.LogWarning((object)"[ai-toggle] could not apply powers to spawned ai worm");
				}
			}
			catch (Exception ex)
			{
				Plugin.log.LogWarning((object)("[ai-toggle] spawned worm loadout failed: " + ex.Message));
			}
		}
	}
	[HarmonyPatch]
	public static class AiWormManager
	{
		public static readonly List<GameObject> ai_worms = new List<GameObject>();

		private static readonly Dictionary<ulong, GameObject> ai_worms_by_client = new Dictionary<ulong, GameObject>();

		private static readonly Dictionary<ulong, int> owner_slots_by_client = new Dictionary<ulong, int>();

		private static readonly Dictionary<ulong, AiWormDifficulty> pending_start_clients = new Dictionary<ulong, AiWormDifficulty>();

		public static bool IsAiWorm(Component c)
		{
			if (LobbyAiState.IsLocalHost && (Object)(object)c != (Object)null)
			{
				return (Object)(object)c.GetComponentInParent<AiWorm>() != (Object)null;
			}
			return false;
		}

		public static bool IsActiveAiWorm(Component c)
		{
			if (!IsAiWorm(c))
			{
				return false;
			}
			AiWorm componentInParent = c.GetComponentInParent<AiWorm>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				return ai_worms.Contains(((Component)componentInParent).gameObject);
			}
			return false;
		}

		[HarmonyPatch(typeof(LobbyManager), "SpawnPlayersAndStartGame")]
		[HarmonyPostfix]
		public static void SpawnPlayersAndStartGame_Postfix()
		{
			ReconcileSpawnedWorms(allow_start_hook: true);
		}

		public static void ReconcileSpawnedWorms()
		{
			ReconcileSpawnedWorms(allow_start_hook: false);
		}

		public static void CaptureStartRoster()
		{
			pending_start_clients.Clear();
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsHost || !LobbyAiState.IsHostEnabled)
			{
				return;
			}
			foreach (ulong enabledClientId in LobbyAiState.GetEnabledClientIds())
			{
				if (singleton.ConnectedClients.ContainsKey(enabledClientId))
				{
					pending_start_clients[enabledClientId] = LobbyAiState.GetClientDifficulty(enabledClientId);
				}
			}
		}

		public static void ClearStartRoster()
		{
			pending_start_clients.Clear();
		}

		private static void ReconcileSpawnedWorms(bool allow_start_hook)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsHost)
			{
				return;
			}
			GameManager singleton2 = GameManager.Singleton;
			if ((Object)(object)singleton2 == (Object)null || (!allow_start_hook && (int)singleton2.gameState != 1 && (int)singleton2.gameState != 3))
			{
				return;
			}
			RemoveMissingEntries();
			Dictionary<ulong, AiWormDifficulty> dictionary = new Dictionary<ulong, AiWormDifficulty>();
			if (allow_start_hook && pending_start_clients.Count > 0)
			{
				foreach (KeyValuePair<ulong, AiWormDifficulty> pending_start_client in pending_start_clients)
				{
					if (singleton.ConnectedClients.ContainsKey(pending_start_client.Key))
					{
						dictionary[pending_start_client.Key] = pending_start_client.Value;
					}
				}
				pending_start_clients.Clear();
			}
			else if (LobbyAiState.IsHostEnabled)
			{
				foreach (ulong enabledClientId in LobbyAiState.GetEnabledClientIds())
				{
					if (singleton.ConnectedClients.ContainsKey(enabledClientId))
					{
						dictionary[enabledClientId] = LobbyAiState.GetClientDifficulty(enabledClientId);
					}
				}
			}
			List<ulong> list = new List<ulong>(dictionary.Keys);
			list.Sort();
			if (list.Count > 16)
			{
				list.RemoveRange(16, list.Count - 16);
			}
			HashSet<ulong> hashSet = new HashSet<ulong>(list);
			foreach (ulong item in new List<ulong>(ai_worms_by_client.Keys))
			{
				if (!hashSet.Contains(item))
				{
					RemoveForClient(item);
				}
			}
			if (list.Count == 0 || !allow_start_hook)
			{
				return;
			}
			Plugin.EnsurePolicyLoaded();
			LobbyAiState.EnsureAiLoadout();
			GameObject wormPrefab = singleton2.wormPrefab;
			if ((Object)(object)wormPrefab == (Object)null)
			{
				Plugin.log.LogError((object)"wormPrefab null; cannot spawn ai worm");
				return;
			}
			int count = ai_worms.Count;
			for (int i = 0; i < list.Count; i++)
			{
				ulong num = list[i];
				if (!ai_worms_by_client.ContainsKey(num))
				{
					int num2 = NextAvailableOwnerSlot();
					if (num2 < 0)
					{
						Plugin.log.LogWarning((object)"no reserved owner id remained for another ai worm");
						break;
					}
					TrySpawnOne(wormPrefab, num, num2, dictionary[num]);
				}
			}
			if (ai_worms.Count != count)
			{
				Plugin.log.LogInfo((object)$"spawned {ai_worms.Count} ai worm(s)");
			}
		}

		[HarmonyPatch(typeof(GameManager), "SwitchGameStateServerRPC")]
		[HarmonyPostfix]
		public static void SwitchGameState_Postfix(int gameStateInt)
		{
			if (LobbyAiState.IsLocalHost && (gameStateInt == 2 || gameStateInt == 0))
			{
				DespawnAll();
			}
		}

		public static void DespawnAll()
		{
			AiWormDifficultyPatches.ResetImpacts();
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsHost)
			{
				return;
			}
			foreach (GameObject ai_worm in ai_worms)
			{
				if (!((Object)(object)ai_worm == (Object)null))
				{
					WormMovement componentInChildren = ai_worm.GetComponentInChildren<WormMovement>();
					WormPerception.Remove(componentInChildren);
					AiWormDifficultyPatches.ForgetImpacts(componentInChildren);
					DespawnOne(ai_worm);
				}
			}
			ai_worms.Clear();
			ai_worms_by_client.Clear();
			owner_slots_by_client.Clear();
			pending_start_clients.Clear();
			WormPerception.Reset();
		}

		public static void RemoveForClient(ulong client_id)
		{
			if (!ai_worms_by_client.TryGetValue(client_id, out var value))
			{
				owner_slots_by_client.Remove(client_id);
				return;
			}
			ai_worms_by_client.Remove(client_id);
			owner_slots_by_client.Remove(client_id);
			ai_worms.Remove(value);
			WormMovement worm = (((Object)(object)value != (Object)null) ? value.GetComponentInChildren<WormMovement>() : null);
			WormPerception.Remove(worm);
			AiWormDifficultyPatches.ForgetImpacts(worm);
			DespawnOne(value);
		}

		private static void DespawnOne(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			WormMouth componentInChildren = go.GetComponentInChildren<WormMouth>(true);
			if (GrabReleasePatches.ReleaseBeforeDespawn(componentInChildren))
			{
				try
				{
					((MonoBehaviour)componentInChildren).StartCoroutine(DespawnAfterRelease(go));
					return;
				}
				catch (Exception ex)
				{
					Plugin.log.LogWarning((object)("delayed ai worm despawn failed: " + ex.Message));
				}
			}
			DespawnNow(go);
		}

		private static IEnumerator DespawnAfterRelease(GameObject go)
		{
			yield return null;
			yield return null;
			DespawnNow(go);
		}

		private static void DespawnNow(GameObject go)
		{
			try
			{
				NetworkObject val = (((Object)(object)go != (Object)null) ? go.GetComponent<NetworkObject>() : null);
				if ((Object)(object)val != (Object)null && val.IsSpawned)
				{
					val.Despawn(true);
				}
				else if ((Object)(object)go != (Object)null)
				{
					Object.Destroy((Object)(object)go);
				}
			}
			catch (Exception ex)
			{
				Plugin.log.LogWarning((object)("ai worm despawn failed: " + ex.Message));
			}
		}

		private static void RemoveMissingEntries()
		{
			ai_worms.RemoveAll((GameObject worm) => (Object)(object)worm == (Object)null);
			foreach (ulong item in new List<ulong>(ai_worms_by_client.Keys))
			{
				if ((Object)(object)ai_worms_by_client[item] == (Object)null)
				{
					ai_worms_by_client.Remove(item);
					owner_slots_by_client.Remove(item);
				}
			}
		}

		private static int NextAvailableOwnerSlot()
		{
			HashSet<int> hashSet = new HashSet<int>(owner_slots_by_client.Values);
			for (int i = 0; i < 16; i++)
			{
				if (!hashSet.Contains(i))
				{
					return i;
				}
			}
			return -1;
		}

		private static void TrySpawnOne(GameObject prefab, ulong requester_client_id, int owner_slot, AiWormDifficulty difficulty)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = null;
			try
			{
				int num = owner_slot % 4;
				int num2 = owner_slot / 4;
				Vector3 val2 = default(Vector3);
				((Vector3)(ref val2))..ctor(((float)num - 1.5f) * 8f, 0f, -12f - (float)num2 * 8f);
				val = Object.Instantiate<GameObject>(prefab, val2, Quaternion.identity);
				if ((Object)(object)MenuToGameBridger.Singleton == (Object)null)
				{
					throw new InvalidOperationException("MenuToGameBridger null");
				}
				AiWorm aiWorm = val.AddComponent<AiWorm>();
				aiWorm.requester_client_id = requester_client_id;
				aiWorm.owner_slot = owner_slot;
				aiWorm.difficulty = difficulty;
				aiWorm.cosmetic_data = AiWormCosmetics.Create(MenuToGameBridger.Singleton.localPlayerCosmeticData);
				aiWorm.has_cosmetic_data = true;
				ApplyDifficulty(val, difficulty);
				NetworkObject component = val.GetComponent<NetworkObject>();
				if ((Object)(object)component == (Object)null)
				{
					throw new InvalidOperationException("worm prefab has no NetworkObject");
				}
				component.SpawnWithOwnership(AiWormNetworkIdentity.OwnerIdFor(owner_slot), false);
				ai_worms.Add(val);
				ai_worms_by_client[requester_client_id] = val;
				owner_slots_by_client[requester_client_id] = owner_slot;
				Plugin.log.LogInfo((object)("spawned " + AiWormDifficultyRules.DisplayName(difficulty) + " " + $"for client {requester_client_id}"));
			}
			catch (Exception arg)
			{
				try
				{
					if ((Object)(object)val != (Object)null)
					{
						NetworkObject component2 = val.GetComponent<NetworkObject>();
						if ((Object)(object)component2 != (Object)null && component2.IsSpawned)
						{
							component2.Despawn(true);
						}
						else
						{
							Object.Destroy((Object)(object)val);
						}
					}
				}
				catch (Exception ex)
				{
					Plugin.log.LogWarning((object)("ai worm spawn cleanup failed: " + ex.Message));
				}
				Plugin.log.LogError((object)$"ai worm spawn failed: {arg}");
			}
		}

		private static void ApplyDifficulty(GameObject go, AiWormDifficulty difficulty)
		{
			WormMovement componentInChildren = go.GetComponentInChildren<WormMovement>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				throw new InvalidOperationException("worm prefab has no WormMovement");
			}
			float num = AiWormDifficultyRules.Multiplier(difficulty);
			float num2 = AiWormDifficultyRules.BurrowMultiplier(difficulty);
			if (!Mathf.Approximately(num, 1f) || !Mathf.Approximately(num2, 1f))
			{
				string[] obj = new string[5] { "surfaceSpeed", "surfaceSpeed_Sneak", "divePower", "aboveGroundDivePower", "diveUpwardsPower" };
				Traverse val = Traverse.Create((object)componentInChildren);
				string[] array = obj;
				foreach (string text in array)
				{
					Traverse obj2 = val.Field(text);
					obj2.SetValue((object)(obj2.GetValue<float>() * num));
				}
				array = new string[2] { "burrowSpeed", "burrowSpeed_Sneak" };
				foreach (string text2 in array)
				{
					Traverse obj3 = val.Field(text2);
					obj3.SetValue((object)(obj3.GetValue<float>() * num2));
				}
				componentInChildren.diveCooldown /= num;
			}
		}
	}
	[HarmonyPatch]
	public static class AiWormNetworkIdentity
	{
		private struct NetworkOwnerState
		{
			public NetworkObject network_object;

			public ulong owner_id;
		}

		public const int MAX_AI_WORMS = 16;

		private const ulong FIRST_OWNER_ID = 18446744073709550591uL;

		public static ulong OwnerIdFor(int index)
		{
			return 18446744073709550591uL - (ulong)index;
		}

		private static bool IsReservedOwnerId(ulong owner_id)
		{
			if (owner_id <= 18446744073709550591uL)
			{
				return owner_id >= 18446744073709550576uL;
			}
			return false;
		}

		[HarmonyPatch(typeof(NetworkBehaviour), "UpdateNetworkProperties")]
		[HarmonyPostfix]
		private static void UpdateNetworkProperties_Postfix(NetworkBehaviour __instance)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (!((Object)(object)singleton == (Object)null) && singleton.IsHost && !((Object)(object)__instance == (Object)null) && !((Object)(object)((Component)__instance).GetComponentInParent<AiWorm>() == (Object)null))
			{
				Traverse obj = Traverse.Create((object)__instance);
				obj.Property("IsOwner", (object[])null).SetValue((object)true);
				obj.Property("OwnerClientId", (object[])null).SetValue((object)singleton.LocalClientId);
			}
		}

		[HarmonyPatch(typeof(NetworkVariableBase), "CanClientWrite")]
		[HarmonyPostfix]
		private static void CanClientWrite_Postfix(NetworkVariableBase __instance, ulong clientId, ref bool __result)
		{
			if (!__result)
			{
				NetworkManager singleton = NetworkManager.Singleton;
				NetworkBehaviour val = ((__instance != null) ? __instance.GetBehaviour() : null);
				if ((Object)(object)singleton != (Object)null && singleton.IsHost && clientId == singleton.LocalClientId && (Object)(object)val != (Object)null && (Object)(object)((Component)val).GetComponentInParent<AiWorm>() != (Object)null)
				{
					__result = true;
				}
			}
		}

		[HarmonyPatch(typeof(WormPlayer), "DamageWorm_ServerRPC")]
		[HarmonyPrefix]
		private static void DamageWorm_Prefix(WormPlayer __instance, ref NetworkOwnerState __state)
		{
			__state = default(NetworkOwnerState);
			NetworkManager singleton = NetworkManager.Singleton;
			if (!((Object)(object)singleton == (Object)null) && singleton.IsHost && !((Object)(object)__instance == (Object)null) && !((Object)(object)((Component)__instance).GetComponentInParent<AiWorm>() == (Object)null))
			{
				NetworkObject networkObject = ((NetworkBehaviour)__instance).NetworkObject;
				if (!((Object)(object)networkObject == (Object)null))
				{
					__state.network_object = networkObject;
					__state.owner_id = networkObject.OwnerClientId;
					Traverse.Create((object)networkObject).Property("OwnerClientId", (object[])null).SetValue((object)singleton.LocalClientId);
				}
			}
		}

		[HarmonyPatch(typeof(WormPlayer), "DamageWorm_ServerRPC")]
		[HarmonyFinalizer]
		private static Exception DamageWorm_Finalizer(Exception __exception, NetworkOwnerState __state)
		{
			if ((Object)(object)__state.network_object != (Object)null)
			{
				Traverse.Create((object)__state.network_object).Property("OwnerClientId", (object[])null).SetValue((object)__state.owner_id);
			}
			return __exception;
		}

		[HarmonyPatch(typeof(EventFeedManager), "GetPlayerNamesFromServerAndCreateEventStringsWithThem_ServerRPC")]
		[HarmonyPrefix]
		private static void EventFeed_Prefix(ref ulong _playerID1, ref ulong _playerID2)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (!((Object)(object)singleton == (Object)null) && singleton.IsHost)
			{
				if (IsReservedOwnerId(_playerID1))
				{
					_playerID1 = singleton.LocalClientId;
				}
				if (IsReservedOwnerId(_playerID2))
				{
					_playerID2 = singleton.LocalClientId;
				}
			}
		}
	}
	[HarmonyPatch]
	public static class BileBombRedirect
	{
		private const float ARM_WINDOW_SECONDS = 0.5f;

		private const float TRAVEL_SPEED = 40f;

		private const float ARRIVAL_RADIUS = 1f;

		private static bool armed;

		private static Vector3 armed_target;

		private static float armed_at = float.NegativeInfinity;

		private static readonly Dictionary<BileBombProjectile, Vector3> redirects = new Dictionary<BileBombProjectile, Vector3>();

		public static void Arm(Vector3 target)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			armed = true;
			armed_target = target;
			armed_at = Time.time;
		}

		[HarmonyPatch(typeof(BileBombProjectile), "OnNetworkSpawn")]
		[HarmonyPostfix]
		public static void OnNetworkSpawn_Postfix(BileBombProjectile __instance)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (armed && !((Object)(object)__instance == (Object)null))
			{
				armed = false;
				if (Time.time - armed_at <= 0.5f)
				{
					redirects[__instance] = armed_target;
				}
			}
		}

		[HarmonyPatch(typeof(BileBombProjectile), "Update")]
		[HarmonyPrefix]
		public static void Update_Prefix(BileBombProjectile __instance)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || !redirects.TryGetValue(__instance, out var value))
			{
				return;
			}
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsHost)
			{
				return;
			}
			Rigidbody component = ((Component)__instance).GetComponent<Rigidbody>();
			if (!((Object)(object)component == (Object)null))
			{
				Collider component2 = ((Component)__instance).GetComponent<Collider>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.isTrigger = true;
				}
				component.useGravity = false;
				component.angularVelocity = Vector3.zero;
				Vector3 val = value - ((Component)__instance).transform.position;
				float magnitude = ((Vector3)(ref val)).magnitude;
				component.velocity = ((magnitude <= 1f) ? Vector3.zero : (val / magnitude * 40f));
			}
		}
	}
	[HarmonyPatch]
	public static class GrabReleasePatches
	{
		private class ForcedRelease
		{
			public ulong worm_owner_id;

			public float expires_at;
		}

		private static readonly Dictionary<ulong, WormMouth> ai_grabber = new Dictionary<ulong, WormMouth>();

		private static readonly Dictionary<ulong, ForcedRelease> forced_releases = new Dictionary<ulong, ForcedRelease>();

		private static readonly MethodInfo mini_game_ended_client_rpc = AccessTools.Method(typeof(StruggleMiniGameHandler), "MiniGameEnded_ClientRPC", new Type[1] { typeof(ulong) }, (Type[])null);

		private static WormMouth last_ai_mouth;

		[HarmonyPatch(typeof(WormMouth), "GrabPlayer_Server")]
		[HarmonyPrefix]
		public static bool GrabPlayer_Server_Prefix(WormMouth __instance, NetworkObject pObject, ref bool __result)
		{
			if ((Object)(object)pObject != (Object)null && forced_releases.TryGetValue(pObject.OwnerClientId, out var value))
			{
				if (Time.unscaledTime <= value.expires_at)
				{
					__result = false;
					return false;
				}
				forced_releases.Remove(pObject.OwnerClientId);
			}
			if (AiWormManager.IsAiWorm((Component)(object)__instance))
			{
				last_ai_mouth = __instance;
			}
			return true;
		}

		[HarmonyPatch(typeof(WormMouth), "GrabPlayer_Server")]
		[HarmonyPostfix]
		public static void GrabPlayer_Server_Postfix(WormMouth __instance, NetworkObject pObject, bool __result)
		{
			if (__result && AiWormManager.IsAiWorm((Component)(object)__instance) && (Object)(object)pObject != (Object)null)
			{
				ai_grabber[pObject.OwnerClientId] = __instance;
				Player componentInParent = ((Component)pObject).GetComponentInParent<Player>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					WormPerception.OnTargetGrabbed(((Component)__instance).GetComponentInParent<WormMovement>(), componentInParent);
				}
			}
		}

		[HarmonyPatch(typeof(StruggleMiniGameHandler), "StartNewStruggleMiniGame_ClientRPC")]
		[HarmonyPrefix]
		public static void StartStruggle_Prefix(ref ulong _wormPlayerObjectID)
		{
			if (!LobbyAiState.IsLocalHost || (Object)(object)last_ai_mouth == (Object)null || (Object)(object)((NetworkBehaviour)last_ai_mouth).NetworkObject == (Object)null)
			{
				return;
			}
			NetworkManager singleton = NetworkManager.Singleton;
			if (!((Object)(object)singleton == (Object)null))
			{
				Dictionary<ulong, NetworkObject> spawnedObjects = singleton.SpawnManager.SpawnedObjects;
				if (!spawnedObjects.ContainsKey(_wormPlayerObjectID) || !((Object)(object)((Component)spawnedObjects[_wormPlayerObjectID]).GetComponentInChildren<WormMouth>() != (Object)null))
				{
					_wormPlayerObjectID = ((NetworkBehaviour)last_ai_mouth).NetworkObject.NetworkObjectId;
				}
			}
		}

		[HarmonyPatch(typeof(StruggleMiniGameHandler), "InformWormTheMiniGameIsOver_ServerRPC")]
		[HarmonyPrefix]
		public static bool InformWormTheMiniGameIsOver_Prefix(StruggleMiniGameHandler __instance, ulong _wormPlayerID, ulong _humanPlayerID, int _damage)
		{
			if (forced_releases.TryGetValue(_humanPlayerID, out var value))
			{
				if (Time.unscaledTime <= value.expires_at && value.worm_owner_id == _wormPlayerID)
				{
					forced_releases.Remove(_humanPlayerID);
					ai_grabber.Remove(_humanPlayerID);
					ClearGrabbedFlag(_humanPlayerID);
					return false;
				}
				if (Time.unscaledTime > value.expires_at)
				{
					forced_releases.Remove(_humanPlayerID);
				}
			}
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsHost || !ai_grabber.TryGetValue(_humanPlayerID, out var value2) || (Object)(object)value2 == (Object)null)
			{
				return true;
			}
			try
			{
				value2.PlayerMiniGameEnded_ServerRPC(_damage);
				if ((Object)(object)LobbyManager.Singleton != (Object)null && LobbyManager.Singleton.cachedClients.ContainsKey(_humanPlayerID))
				{
					Player component = ((Component)LobbyManager.Singleton.cachedClients[_humanPlayerID].PlayerObject).GetComponent<Player>();
					if ((Object)(object)component != (Object)null)
					{
						component.currentlyInWormMouth.Value = false;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.log.LogWarning((object)("ai grab-release reroute failed: " + ex.Message));
			}
			((MonoBehaviour)__instance).StartCoroutine(BroadcastMiniGameEndedNextFrame(__instance, _humanPlayerID));
			ai_grabber.Remove(_humanPlayerID);
			return false;
		}

		public static bool ReleaseBeforeDespawn(WormMouth mouth)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			if ((Object)(object)mouth == (Object)null || (int)mouth.thingInMouthType.Value != 2 || mouth.playerIDInMouth == 1000000)
			{
				return false;
			}
			ulong playerIDInMouth = mouth.playerIDInMouth;
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsHost || !singleton.ConnectedClients.ContainsKey(playerIDInMouth))
			{
				return false;
			}
			forced_releases[playerIDInMouth] = new ForcedRelease
			{
				worm_owner_id = ((NetworkBehaviour)mouth).OwnerClientId,
				expires_at = Time.unscaledTime + 10f
			};
			ai_grabber.Remove(playerIDInMouth);
			if ((Object)(object)last_ai_mouth == (Object)(object)mouth)
			{
				last_ai_mouth = null;
			}
			ClearGrabbedFlag(playerIDInMouth);
			try
			{
				mouth.DropPlayerInOurMouth_ServerRPC();
				return true;
			}
			catch (Exception ex)
			{
				forced_releases.Remove(playerIDInMouth);
				Plugin.log.LogWarning((object)("ai grab release before despawn failed: " + ex.Message));
				return false;
			}
		}

		public static void ReconcileMouthFlags()
		{
			NetworkManager singleton = NetworkManager.Singleton;
			GameManager singleton2 = GameManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsHost || (Object)(object)singleton2 == (Object)null || singleton2.humanPlayerScripts == null)
			{
				return;
			}
			foreach (Player humanPlayerScript in singleton2.humanPlayerScripts)
			{
				if ((Object)(object)humanPlayerScript == (Object)null)
				{
					continue;
				}
				bool value;
				try
				{
					value = humanPlayerScript.currentlyInWormMouth.Value;
				}
				catch
				{
					continue;
				}
				if (value && !IsHeldByAnyMouth(((NetworkBehaviour)humanPlayerScript).OwnerClientId))
				{
					try
					{
						humanPlayerScript.currentlyInWormMouth.Value = false;
					}
					catch
					{
					}
				}
			}
		}

		private static bool IsHeldByAnyMouth(ulong owner_id)
		{
			foreach (GameObject ai_worm in AiWormManager.ai_worms)
			{
				if ((Object)(object)ai_worm != (Object)null && MouthHolds(ai_worm.GetComponentInChildren<WormMouth>(true), owner_id))
				{
					return true;
				}
			}
			GameManager singleton = GameManager.Singleton;
			if ((Object)(object)singleton != (Object)null && singleton.wormPlayerScripts != null)
			{
				foreach (WormPlayer wormPlayerScript in singleton.wormPlayerScripts)
				{
					if ((Object)(object)wormPlayerScript != (Object)null && MouthHolds(((Component)wormPlayerScript).GetComponentInChildren<WormMouth>(true), owner_id))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool MouthHolds(WormMouth mouth, ulong owner_id)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			if ((Object)(object)mouth != (Object)null && (int)mouth.thingInMouthType.Value == 2)
			{
				return mouth.playerIDInMouth == owner_id;
			}
			return false;
		}

		private static void ClearGrabbedFlag(ulong human_player_id)
		{
			if (!((Object)(object)LobbyManager.Singleton == (Object)null) && LobbyManager.Singleton.cachedClients.ContainsKey(human_player_id))
			{
				Player component = ((Component)LobbyManager.Singleton.cachedClients[human_player_id].PlayerObject).GetComponent<Player>();
				if ((Object)(object)component != (Object)null)
				{
					component.currentlyInWormMouth.Value = false;
				}
			}
		}

		private static IEnumerator BroadcastMiniGameEndedNextFrame(StruggleMiniGameHandler handler, ulong human_player_id)
		{
			yield return null;
			if ((Object)(object)handler == (Object)null || mini_game_ended_client_rpc == null)
			{
				Plugin.log.LogWarning((object)"ai grab-release cleanup rpc was unavailable");
				yield break;
			}
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsHost || !singleton.IsListening || !singleton.ConnectedClients.TryGetValue(human_player_id, out var value) || (Object)(object)value.PlayerObject == (Object)null || !singleton.SpawnManager.SpawnedObjects.ContainsKey(value.PlayerObject.NetworkObjectId))
			{
				yield break;
			}
			try
			{
				mini_game_ended_client_rpc.Invoke(handler, new object[1] { value.PlayerObject.NetworkObjectId });
			}
			catch (Exception ex)
			{
				Plugin.log.LogWarning((object)("ai grab-release cleanup broadcast failed: " + ex.Message));
			}
		}
	}
	[HarmonyPatch]
	public static class HeartJarDropPatches
	{
		private const ulong NO_JAR = 1000000uL;

		[HarmonyPatch(typeof(HeartJarManager), "HandleDictionaryTimesAndSpawningJars")]
		[HarmonyPrefix]
		public static void HandleDictionaryTimes_Prefix(HeartJarManager __instance)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager singleton = NetworkManager.Singleton;
			GameManager singleton2 = GameManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsHost || (Object)(object)singleton2 == (Object)null || (int)singleton2.gameState != 1 || __instance.heartJarInfo_MasterDictionary == null)
			{
				return;
			}
			List<HeartJarInfo> list = null;
			foreach (HeartJarInfo value in __instance.heartJarInfo_MasterDictionary.Values)
			{
				if (value != null && (int)value.lastCauseOfDeath == 0 && !(value.timeBeforeDigested > 0f) && IsSpawnable(value.heartJarState) && !VanillaCanResolve(singleton, value.wormIdWhoAteThem))
				{
					(list ?? (list = new List<HeartJarInfo>())).Add(value);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (HeartJarInfo item in list)
			{
				try
				{
					DropEatenJar(__instance, singleton, singleton2, item);
				}
				catch (Exception ex)
				{
					Plugin.log.LogWarning((object)("ai heart-jar drop failed: " + ex.Message));
				}
			}
		}

		private static void DropEatenJar(HeartJarManager manager, NetworkManager nm, GameManager gm, HeartJarInfo info)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ResolveDropPosition(nm, info);
			float num = gm.CalculateSurfacedYPosition(val);
			if (val.y <= num)
			{
				val.y = num;
			}
			NetworkObject value;
			if ((int)info.heartJarState == 0)
			{
				Traverse.Create((object)manager).Method("SpawnPlayerHeartJar_ServerRPC", new object[3] { info.ownerID, val, true }).GetValue();
			}
			else if (info.spawnedJarObjectID != 1000000 && nm.SpawnManager.SpawnedObjects.TryGetValue(info.spawnedJarObjectID, out value) && (Object)(object)value != (Object)null)
			{
				Traverse.Create((object)manager).Method("SetHeartJarToInteractable_ServerRPC", new object[1] { info.spawnedJarObjectID }).GetValue();
				Rigidbody component = ((Component)value).GetComponent<Rigidbody>();
				if ((Object)(object)component != (Object)null)
				{
					component.velocity = Vector3.zero;
				}
				Component component2 = ((Component)value).GetComponent("NetworkTransform");
				if ((Object)(object)component2 != (Object)null)
				{
					Traverse.Create((object)component2).Method("Teleport", new object[3]
					{
						val,
						((Component)value).transform.rotation,
						((Component)value).transform.localScale
					}).GetValue();
				}
				else
				{
					((Component)value).transform.position = val;
				}
				if ((Object)(object)component != (Object)null)
				{
					Traverse.Create((object)manager).Method("HeartJarBoopUpwardForce", new object[1] { component }).GetValue();
				}
			}
			info.heartJarState = (HeartJarState)3;
		}

		private static Vector3 ResolveDropPosition(NetworkManager nm, HeartJarInfo info)
		{
			//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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			foreach (GameObject ai_worm in AiWormManager.ai_worms)
			{
				if (!((Object)(object)ai_worm == (Object)null))
				{
					InGameWormCosmeticBuilder componentInChildren = ai_worm.GetComponentInChildren<InGameWormCosmeticBuilder>(true);
					if ((Object)(object)componentInChildren != (Object)null)
					{
						return componentInChildren.GetWormTailPosition() + Vector3.up;
					}
				}
			}
			if (nm.ConnectedClients.TryGetValue(info.ownerID, out var value) && (Object)(object)value.PlayerObject != (Object)null)
			{
				return ((Component)value.PlayerObject).transform.position + Vector3.up;
			}
			return new Vector3(0f, 10f, 0f);
		}

		private static bool VanillaCanResolve(NetworkManager nm, ulong worm_id)
		{
			if (nm.ConnectedClients.TryGetValue(worm_id, out var value) && (Object)(object)value.PlayerObject != (Object)null)
			{
				return (Object)(object)((Component)value.PlayerObject).GetComponent<InGameWormCosmeticBuilder>() != (Object)null;
			}
			return false;
		}

		private static bool IsSpawnable(HeartJarState state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Invalid comparison between Unknown and I4
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			if ((int)state != 0 && (int)state != 1)
			{
				return (int)state == 2;
			}
			return true;
		}
	}
	public class LobbyAiState : MonoBehaviour
	{
		private const string PREFERENCE_MESSAGE = "com.wormtown.ai.preference.v3";

		private const string PREFERENCE_ACK_MESSAGE = "com.wormtown.ai.preference-ack.v3";

		private const byte PROTOCOL_VERSION = 3;

		private const float PREFERENCE_RETRY_INITIAL_SECONDS = 1f;

		private const float PREFERENCE_RETRY_MAX_SECONDS = 10f;

		private const float PREFERENCE_CHANGE_COOLDOWN = 0.25f;

		private const float MOUTH_RECONCILE_INTERVAL = 0.5f;

		private const string SERVICE_OBJECT_NAME = "WormtownAI Runtime Services";

		private static LobbyAiState instance;

		private readonly Dictionary<ulong, AiWormDifficulty> enabled_clients = new Dictionary<ulong, AiWormDifficulty>();

		private readonly Dictionary<ulong, float> next_preference_change_time = new Dictionary<ulong, float>();

		private NetworkManager network_manager;

		private bool registered_as_host;

		private bool preference_acknowledged;

		private float next_preference_send_time;

		private float preference_retry_seconds;

		private float next_mouth_reconcile;

		private WormAbilityPickerBank applied_picker;

		private bool loadout_saved;

		private bool logged_loadout_error;

		private int bile_bomb_index = -1;

		private int sand_storm_index = -1;

		public static bool IsLocalHost
		{
			get
			{
				NetworkManager singleton = NetworkManager.Singleton;
				if ((Object)(object)singleton != (Object)null)
				{
					return singleton.IsHost;
				}
				return false;
			}
		}

		public static bool IsHostEnabled
		{
			get
			{
				MenuToGameBridger singleton = MenuToGameBridger.Singleton;
				if (IsLocalHost && EnabledWormCount > 0)
				{
					if (!((Object)(object)singleton == (Object)null))
					{
						if (!singleton.isWormTutorial)
						{
							return !singleton.isPardnerTutorial;
						}
						return false;
					}
					return true;
				}
				return false;
			}
		}

		public static int EnabledWormCount
		{
			get
			{
				if (!IsLocalHost)
				{
					return 0;
				}
				if ((Object)(object)instance != (Object)null && instance.registered_as_host)
				{
					return instance.enabled_clients.Count;
				}
				return Settings.ai_enabled ? 1 : 0;
			}
		}

		public static bool IsClientEnabled(ulong client_id)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null)
			{
				return false;
			}
			if (client_id == singleton.LocalClientId)
			{
				if (Settings.ai_enabled)
				{
					if (!singleton.IsHost)
					{
						if ((Object)(object)instance != (Object)null && (Object)(object)instance.network_manager == (Object)(object)singleton)
						{
							return instance.preference_acknowledged;
						}
						return false;
					}
					return true;
				}
				return false;
			}
			if (singleton.IsHost && (Object)(object)instance != (Object)null && instance.registered_as_host)
			{
				return instance.enabled_clients.ContainsKey(client_id);
			}
			return false;
		}

		public static AiWormDifficulty GetClientDifficulty(ulong client_id)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton != (Object)null && client_id == singleton.LocalClientId)
			{
				return Settings.ai_difficulty;
			}
			if ((Object)(object)singleton != (Object)null && singleton.IsHost && (Object)(object)instance != (Object)null && instance.enabled_clients.TryGetValue(client_id, out var value))
			{
				return value;
			}
			return AiWormDifficulty.Garden;
		}

		public static IEnumerable<ulong> GetEnabledClientIds()
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsHost)
			{
				yield break;
			}
			if ((Object)(object)instance != (Object)null && instance.registered_as_host)
			{
				foreach (ulong key in instance.enabled_clients.Keys)
				{
					yield return key;
				}
			}
			else if (Settings.ai_enabled)
			{
				yield return singleton.LocalClientId;
			}
		}

		public static void Initialize(bool enabled, AiWormDifficulty difficulty)
		{
			Settings.ai_enabled = enabled;
			Settings.ai_difficulty = AiWormDifficultyRules.Clamp((int)difficulty);
		}

		public static bool EnsureAvailable()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			if ((Object)(object)instance != (Object)null)
			{
				return true;
			}
			try
			{
				LobbyAiState lobbyAiState = Object.FindObjectOfType<LobbyAiState>();
				GameObject val = (((Object)(object)lobbyAiState != (Object)null) ? ((Component)lobbyAiState).gameObject : GameObject.Find("WormtownAI Runtime Services"));
				if ((Object)(object)val == (Object)null)
				{
					val = new GameObject("WormtownAI Runtime Services");
					Object.DontDestroyOnLoad((Object)(object)val);
				}
				lobbyAiState = val.GetComponent<LobbyAiState>();
				if ((Object)(object)lobbyAiState == (Object)null)
				{
					lobbyAiState = val.AddComponent<LobbyAiState>();
				}
				instance = lobbyAiState;
				return (Object)(object)instance != (Object)null;
			}
			catch (Exception ex)
			{
				Plugin.log.LogWarning((object)("[ai-toggle] coordinator creation failed: " + ex.Message));
				return false;
			}
		}

		public static void SetLocalEnabled(bool enabled)
		{
			if (!EnsureAvailable())
			{
				Plugin.log.LogWarning((object)"[ai-toggle] coordinator unavailable; setting unchanged");
				return;
			}
			Settings.ai_enabled = enabled;
			Plugin.SaveLocalPreferences();
			instance.applied_picker = null;
			instance.loadout_saved = false;
			TeamPatches.ResetAssignments();
			if ((Object)(object)instance.network_manager != (Object)null && instance.registered_as_host)
			{
				if (instance.SetClientPreference(instance.network_manager.LocalClientId, enabled, Settings.ai_difficulty))
				{
					instance.OnEnabledClientsChanged();
				}
			}
			else
			{
				instance.ResetPreferenceSends();
				instance.TrySendLocalPreference();
			}
			Plugin.log.LogInfo((object)$"[ai-toggle] local AI Worm enabled = {enabled}");
		}

		public static void SetLocalDifficulty(AiWormDifficulty difficulty)
		{
			difficulty = AiWormDifficultyRules.Clamp((int)difficulty);
			if (difficulty == Settings.ai_difficulty || !EnsureAvailable())
			{
				return;
			}
			Settings.ai_difficulty = difficulty;
			Plugin.SaveLocalPreferences();
			if ((Object)(object)instance.network_manager != (Object)null && instance.registered_as_host)
			{
				if (instance.SetClientPreference(instance.network_manager.LocalClientId, Settings.ai_enabled, difficulty))
				{
					instance.OnEnabledClientsChanged();
				}
			}
			else
			{
				instance.ResetPreferenceSends();
				instance.TrySendLocalPreference();
			}
			Plugin.log.LogInfo((object)("[ai-toggle] local AI Worm difficulty = " + AiWormDifficultyRules.DisplayName(difficulty)));
		}

		public static bool EnsureAiLoadout()
		{
			if ((Object)(object)instance != (Object)null && IsHostEnabled)
			{
				if (!instance.loadout_saved)
				{
					return instance.TryApplyAiLoadout();
				}
				return true;
			}
			return false;
		}

		public static bool ApplyAiLoadout(WormAbilityManager ability_manager)
		{
			if ((Object)(object)ability_manager == (Object)null || !IsLocalHost)
			{
				return false;
			}
			int num = (((Object)(object)instance != (Object)null) ? instance.bile_bomb_index : (-1));
			int num2 = (((Object)(object)instance != (Object)null) ? instance.sand_storm_index : (-1));
			if (num < 0 || num2 < 0)
			{
				WormAbility[] value = Traverse.Create((object)ability_manager).Field("abilityBank").GetValue<WormAbility[]>();
				num = FindAbilityIndex<WormAbility_BileBomb>(value);
				num2 = FindAbilityIndex<WormAbility_SandStorm>(value);
				if (num < 0 || num2 < 0)
				{
					return false;
				}
				if ((Object)(object)instance != (Object)null)
				{
					instance.bile_bomb_index = num;
					instance.sand_storm_index = num2;
				}
			}
			ability_manager.AddAbility(1, num);
			ability_manager.AddAbility(2, num2);
			return true;
		}

		private void Awake()
		{
			if ((Object)(object)instance != (Object)null && (Object)(object)instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			instance = this;
			Plugin.log.LogInfo((object)"[ai-toggle] coordinator ready");
		}

		private void OnDestroy()
		{
			UnregisterNetworkManager();
			if ((Object)(object)instance == (Object)(object)this)
			{
				instance = null;
				Plugin.log.LogInfo((object)"[ai-toggle] coordinator stopped");
			}
		}

		private void Update()
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)network_manager != (Object)null && ((Object)(object)network_manager != (Object)(object)singleton || !network_manager.IsListening))
			{
				UnregisterNetworkManager();
			}
			if ((Object)(object)network_manager == (Object)null && (Object)(object)singleton != (Object)null && singleton.IsListening)
			{
				RegisterNetworkManager(singleton);
			}
			if ((Object)(object)network_manager == (Object)null)
			{
				return;
			}
			if (registered_as_host)
			{
				if (IsHostEnabled)
				{
					TeamPatches.EnsureEnabledPlayersArePardners();
					if (!loadout_saved || (Object)(object)applied_picker != (Object)(object)WormAbilityPickerBank.Singleton)
					{
						TryApplyAiLoadout();
					}
					if (Time.unscaledTime >= next_mouth_reconcile)
					{
						next_mouth_reconcile = Time.unscaledTime + 0.5f;
						GrabReleasePatches.ReconcileMouthFlags();
					}
				}
			}
			else
			{
				TrySendLocalPreference();
			}
		}

		private void RegisterNetworkManager(NetworkManager manager)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			network_manager = manager;
			registered_as_host = manager.IsHost;
			preference_acknowledged = false;
			enabled_clients.Clear();
			next_preference_change_time.Clear();
			manager.CustomMessagingManager.RegisterNamedMessageHandler("com.wormtown.ai.preference.v3", new HandleNamedMessageDelegate(ReceivePreference));
			manager.CustomMessagingManager.RegisterNamedMessageHandler("com.wormtown.ai.preference-ack.v3", new HandleNamedMessageDelegate(ReceivePreferenceAck));
			manager.OnClientConnectedCallback += OnClientConnected;
			manager.OnClientDisconnectCallback += OnClientDisconnected;
			TeamPatches.ResetAssignments();
			if (registered_as_host)
			{
				SetClientPreference(manager.LocalClientId, Settings.ai_enabled, Settings.ai_difficulty);
				OnEnabledClientsChanged();
			}
			else
			{
				ResetPreferenceSends();
			}
		}

		private void UnregisterNetworkManager()
		{
			if (!((Object)(object)network_manager == (Object)null))
			{
				try
				{
					network_manager.CustomMessagingManager.UnregisterNamedMessageHandler("com.wormtown.ai.preference.v3");
					network_manager.CustomMessagingManager.UnregisterNamedMessageHandler("com.wormtown.ai.preference-ack.v3");
					network_manager.OnClientConnectedCallback -= OnClientConnected;
					network_manager.OnClientDisconnectCallback -= OnClientDisconnected;
				}
				catch
				{
				}
				network_manager = null;
				registered_as_host = false;
				preference_acknowledged = false;
				enabled_clients.Clear();
				next_preference_change_time.Clear();
				applied_picker = null;
				TeamPatches.ResetAssignments();
			}
		}

		private void OnClientConnected(ulong client_id)
		{
			if (!registered_as_host && (Object)(object)network_manager != (Object)null && client_id == network_manager.LocalClientId)
			{
				ResetPreferenceSends();
			}
		}

		private void OnClientDisconnected(ulong client_id)
		{
			next_preference_change_time.Remove(client_id);
			if (registered_as_host && enabled_clients.Remove(client_id))
			{
				OnEnabledClientsChanged();
			}
		}

		private bool SetClientPreference(ulong client_id, bool enabled, AiWormDifficulty difficulty)
		{
			if (!enabled)
			{
				return enabled_clients.Remove(client_id);
			}
			difficulty = AiWormDifficultyRules.Clamp((int)difficulty);
			if (enabled_clients.TryGetValue(client_id, out var value) && value == difficulty)
			{
				return false;
			}
			enabled_clients[client_id] = difficulty;
			return true;
		}

		private void OnEnabledClientsChanged()
		{
			applied_picker = null;
			loadout_saved = false;
			TeamPatches.ResetAssignments();
			if (IsHostEnabled)
			{
				try
				{
					ApplyEnabledEffects();
				}
				catch (Exception ex)
				{
					Plugin.log.LogWarning((object)("[ai-toggle] enable side effect failed: " + ex.Message));
				}
			}
			AiWormManager.ReconcileSpawnedWorms();
		}

		private void ResetPreferenceSends()
		{
			preference_acknowledged = false;
			next_preference_send_time = Time.unscaledTime;
			preference_retry_seconds = 1f;
		}

		private unsafe void TrySendLocalPreference()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if (registered_as_host || preference_acknowledged || (Object)(object)network_manager == (Object)null || !network_manager.IsConnectedClient || Time.unscaledTime < next_preference_send_time)
			{
				return;
			}
			try
			{
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(3, (Allocator)2, 3);
				try
				{
					((FastBufferWriter)(ref val)).WriteByteSafe((byte)3);
					((FastBufferWriter)(ref val)).WriteByteSafe(Settings.ai_enabled ? ((byte)1) : ((byte)0));
					((FastBufferWriter)(ref val)).WriteByteSafe((byte)Settings.ai_difficulty);
					network_manager.CustomMessagingManager.SendNamedMessage("com.wormtown.ai.preference.v3", 0uL, val, (NetworkDelivery)2);
				}
				finally
				{
					((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
				}
			}
			catch
			{
			}
			next_preference_send_time = Time.unscaledTime + preference_retry_seconds;
			preference_retry_seconds = Mathf.Min(10f, preference_retry_seconds * 2f);
		}

		private void ReceivePreference(ulong sender_client_id, FastBufferReader reader)
		{
			if (!registered_as_host || (Object)(object)network_manager == (Object)null || !network_manager.IsHost || !network_manager.ConnectedClients.ContainsKey(sender_client_id) || ((FastBufferReader)(ref reader)).Length < 3)
			{
				return;
			}
			byte b = default(byte);
			byte b2 = default(byte);
			byte b3 = default(byte);
			try
			{
				((FastBufferReader)(ref reader)).ReadByteSafe(ref b);
				((FastBufferReader)(ref reader)).ReadByteSafe(ref b2);
				((FastBufferReader)(ref reader)).ReadByteSafe(ref b3);
			}
			catch
			{
				return;
			}
			if (b != 3 || b2 > 1 || b3 > 2)
			{
				return;
			}
			bool flag = b2 != 0;
			AiWormDifficulty aiWormDifficulty = (AiWormDifficulty)b3;
			AiWormDifficulty value;
			bool flag2 = enabled_clients.TryGetValue(sender_client_id, out value);
			bool flag3 = flag2 != flag;
			if (flag3 || (flag && value != aiWormDifficulty))
			{
				if (!IsPreferenceChangeAllowed() || (flag3 && next_preference_change_time.TryGetValue(sender_client_id, out var value2) && Time.unscaledTime < value2))
				{
					SendPreferenceAck(sender_client_id, flag2, flag2 ? value : aiWormDifficulty);
					return;
				}
				if (flag3)
				{
					next_preference_change_time[sender_client_id] = Time.unscaledTime + 0.25f;
				}
				SetClientPreference(sender_client_id, flag, aiWormDifficulty);
				OnEnabledClientsChanged();
				Plugin.log.LogInfo((object)($"[ai-toggle] client {sender_client_id} AI Worm enabled = {flag}, " + "difficulty = " + AiWormDifficultyRules.DisplayName(aiWormDifficulty)));
			}
			SendPreferenceAck(sender_client_id, flag, aiWormDifficulty);
		}

		private void ReceivePreferenceAck(ulong sender_client_id, FastBufferReader reader)
		{
			if (!registered_as_host && !((Object)(object)network_manager == (Object)null) && sender_client_id == 0L && ((FastBufferReader)(ref reader)).Length >= 3)
			{
				byte b = default(byte);
				byte b2 = default(byte);
				byte b3 = default(byte);
				try
				{
					((FastBufferReader)(ref reader)).ReadByteSafe(ref b);
					((FastBufferReader)(ref reader)).ReadByteSafe(ref b2);
					((FastBufferReader)(ref reader)).ReadByteSafe(ref b3);
				}
				catch
				{
					return;
				}
				if (b == 3 && b2 != 0 == Settings.ai_enabled && (uint)b3 == (uint)Settings.ai_difficulty)
				{
					preference_acknowledged = true;
				}
			}
		}

		private static bool IsPreferenceChangeAllowed()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			GameManager singleton = GameManager.Singleton;
			MenuToGameBridger singleton2 = MenuToGameBridger.Singleton;
			if ((Object)(object)singleton != (Object)null && (int)singleton.gameState == 0)
			{
				if (!((Object)(object)singleton2 == (Object)null))
				{
					if (!singleton2.isWormTutorial)
					{
						return !singleton2.isPardnerTutorial;
					}
					return false;
				}
				return true;
			}
			return false;
		}

		private unsafe void SendPreferenceAck(ulong client_id, bool enabled, AiWormDifficulty difficulty)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(3, (Allocator)2, 3);
				try
				{
					((FastBufferWriter)(ref val)).WriteByteSafe((byte)3);
					((FastBufferWriter)(ref val)).WriteByteSafe(enabled ? ((byte)1) : ((byte)0));
					((FastBufferWriter)(ref val)).WriteByteSafe((byte)difficulty);
					network_manager.CustomMessagingManager.SendNamedMessage("com.wormtown.ai.preference-ack.v3", client_id, val, (NetworkDelivery)2);
				}
				finally
				{
					((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
				}
			}
			catch
			{
			}
		}

		private void ApplyEnabledEffects()
		{
			if (IsHostEnabled)
			{
				Plugin.EnsurePolicyLoaded();
				TeamPatches.EnsureEnabledPlayersArePardners();
				TryApplyAiLoadout();
			}
		}

		private bool TryApplyAiLoadout()
		{
			try
			{
				MenuToGameBridger singleton = MenuToGameBridger.Singleton;
				if (!IsHostEnabled || (Object)(object)singleton == (Object)null || singleton.savedWormAbilitySet == null || !TryResolveAiLoadout(null))
				{
					return false;
				}
				singleton.savedWormAbilitySet.savedSlotAbilityIndex_1 = bile_bomb_index;
				singleton.savedWormAbilitySet.savedSlotAbilityIndex_2 = sand_storm_index;
				loadout_saved = true;
				WormAbilityPickerBank singleton2 = WormAbilityPickerBank.Singleton;
				if ((Object)(object)singleton2 == (Object)null)
				{
					return true;
				}
				if (singleton2.slotButtons == null || singleton2.slotButtons.Length < 3 || singleton2.pickerBank == null || bile_bomb_index >= singleton2.pickerBank.Length || sand_storm_index >= singleton2.pickerBank.Length)
				{
					LogLoadoutError("could not refresh the worm ability picker");
					return true;
				}
				singleton2.AssignNewAbility(1, bile_bomb_index);
				singleton2.AssignNewAbility(2, sand_storm_index);
				applied_picker = singleton2;
				logged_loadout_error = false;
				Plugin.log.LogInfo((object)"[ai-toggle] set worm powers to Bile Bomb and Sandstorm");
				return true;
			}
			catch (Exception ex)
			{
				LogLoadoutError("could not assign the required worm abilities: " + ex.Message);
				return false;
			}
		}

		private bool TryResolveAiLoadout(WormAbilityManager ability_manager)
		{
			if (bile_bomb_index >= 0 && sand_storm_index >= 0)
			{
				return true;
			}
			if ((Object)(object)ability_manager == (Object)null && (Object)(object)GameManager.Singleton != (Object)null && (Object)(object)GameManager.Singleton.wormPrefab != (Object)null)
			{
				ability_manager = GameManager.Singleton.wormPrefab.GetComponentInChildren<WormAbilityManager>(true);
			}
			WormAbility[] ability_bank = (((Object)(object)ability_manager != (Object)null) ? Traverse.Create((object)ability_manager).Field("abilityBank").GetValue<WormAbility[]>() : null);
			bile_bomb_index = FindAbilityIndex<WormAbility_BileBomb>(ability_bank);
			sand_storm_index = FindAbilityIndex<WormAbility_SandStorm>(ability_bank);
			if (bile_bomb_index >= 0 && sand_storm_index >= 0)
			{
				return true;
			}
			WormAbilityPickerBank singleton = WormAbilityPickerBank.Singleton;
			WormAbilityUIPicker[] picker_bank = (((Object)(object)singleton != (Object)null) ? singleton.pickerBank : null);
			bile_bomb_index = FindPickerAbilityIndex(picker_bank, "bilebomb");
			sand_storm_index = FindPickerAbilityIndex(picker_bank, "sandstorm");
			if (bile_bomb_index >= 0 && sand_storm_index >= 0)
			{
				return true;
			}
			LogLoadoutError("could not resolve the required worm abilities");
			return false;
		}

		private void LogLoadoutError(string message)
		{
			if (!logged_loadout_error)
			{
				logged_loadout_error = true;
				Plugin.log.LogWarning((object)("[ai-toggle] " + message));
			}
		}

		private static int FindAbilityIndex<TAbility>(WormAbility[] ability_bank) where TAbility : WormAbility
		{
			if (ability_bank == null)
			{
				return -1;
			}
			for (int i = 0; i < ability_bank.Length; i++)
			{
				if (ability_bank[i] is TAbility)
				{
					return i;
				}
			}
			return -1;
		}

		private static int FindPickerAbilityIndex(WormAbilityUIPicker[] picker_bank, string ability_key)
		{
			if (picker_bank == null)
			{
				return -1;
			}
			for (int i = 0; i < picker_bank.Length; i++)
			{
				WormAbilityUIPicker val = picker_bank[i];
				if ((Object)(object)val != (Object)null && (NormalizeAbilityKey(val.abilityName).Contains(ability_key) || NormalizeAbilityKey(((Object)val).name).Contains(ability_key)))
				{
					return i;
				}
			}
			return -1;
		}

		private static string NormalizeAbilityKey(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[value.Length];
			int length = 0;
			foreach (char c in value)
			{
				if (char.IsLetterOrDigit(c))
				{
					array[length++] = char.ToLowerInvariant(c);
				}
			}
			return new string(array, 0, length);
		}
	}
	[HarmonyPatch]
	public static class LobbyAiStatePatches
	{
		[HarmonyPatch(typeof(LobbyManager), "OnNetworkSpawn", new Type[] { })]
		[HarmonyPostfix]
		public static void OnNetworkSpawn_Postfix()
		{
			LobbyAiState.EnsureAvailable();
		}
	}
	[HarmonyPatch]
	public static class LobbySettingsUI
	{
		private const string PANEL_NAME = "Worm AI Panel";

		private const string TOGGLE_BUTTON_NAME = "Toggle Button (ITS A BUTTON, Toggles are dumb)";

		private const float PANEL_HEIGHT = 220f;

		private const float PANEL_GAP = 12f;

		private const float TITLE_Y = 72f;

		private const float TOGGLE_Y = 5f;

		private const float DIFFICULTY_Y = -63f;

		[HarmonyPatch(typeof(ConnectedPlayerLobbyPanel), "SetupPanel")]
		[HarmonyPostfix]
		public static void SetupPanel_Postfix()
		{
			EnsurePanel();
		}

		[HarmonyPatch(typeof(MatchSettingsManager), "OnNetworkSpawn")]
		[HarmonyPostfix]
		public static void MatchSettingsManager_OnNetworkSpawn_Postfix()
		{
			EnsurePanel();
		}

		private static void EnsurePanel()
		{
			try
			{
				LobbyAiState.EnsureAvailable();
				TryAdd();
			}
			catch (Exception ex)
			{
				Plugin.log.LogWarning((object)("[ai-toggle] failed: " + ex.Message));
			}
		}

		private static void TryAdd()
		{
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Expected O, but got Unknown
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_0544: Unknown result type (might be due to invalid IL or missing references)
			//IL_054e: Expected O, but got Unknown
			//IL_05c8: Unknown result type (might be due to invalid IL or missing references)
			MatchSettingsManager val = Object.FindObjectOfType<MatchSettingsManager>();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GameObject val2 = RefGameObject(val, "WormAbilityScream_CheckBox_CheckMarkImage");
			Transform val3 = (((Object)(object)val2 != (Object)null) ? val2.transform.parent : null);
			Transform val4 = (((Object)(object)val3 != (Object)null) ? val3.parent : null);
			Transform val5 = (((Object)(object)val4 != (Object)null) ? val4.parent : null);
			if ((Object)(object)val4 == (Object)null || (Object)(object)val5 == (Object)null || (Object)(object)val5.Find("Worm AI Panel") != (Object)null)
			{
				return;
			}
			Transform val6 = val5.Find("Backer");
			Transform val7 = val5.Find("Worm Settings Header");
			Transform val8 = FindMapGroup(val);
			Transform val9 = (((Object)(object)val8 != (Object)null) ? val8.Find("Backer") : null);
			Transform val10 = (((Object)(object)val9 != (Object)null) ? val9 : val6);
			Component val11 = RefComponent(HudManager.Singleton, "matchSettings_WormAbilityCooldown_DifficultyText");
			Transform val12 = (((Object)(object)val11 != (Object)null) ? FindDirectChildAncestor(val11.transform, val5) : null);
			if ((Object)(object)val6 == (Object)null || (Object)(object)val7 == (Object)null || (Object)(object)val10 == (Object)null || (Object)(object)val12 == (Object)null)
			{
				Plugin.log.LogWarning((object)"[ai-toggle] source panel objects not found");
				return;
			}
			GameObject val13 = null;
			try
			{
				val13 = new GameObject("Worm AI Panel", new Type[1] { typeof(RectTransform) });
				val13.transform.SetParent(val5, false);
				RectTransform component = val13.GetComponent<RectTransform>();
				RectTransform component2 = ((Component)val6).GetComponent<RectTransform>();
				Rect rect = component2.rect;
				float num = Mathf.Abs(((Rect)(ref rect)).width);
				if (num < 1f)
				{
					num = Mathf.Abs(component2.sizeDelta.x);
				}
				rect = component2.rect;
				float num2 = Mathf.Abs(((Rect)(ref rect)).height);
				if (num2 < 1f)
				{
					num2 = Mathf.Abs(component2.sizeDelta.y);
				}
				float num3 = component2.anchoredPosition.y - num2 * component2.pivot.y;
				component.anchorMin = component2.anchorMin;
				component.anchorMax = component2.anchorMax;
				component.pivot = new Vector2(0.5f, 0.5f);
				component.sizeDelta = new Vector2(num, 220f);
				component.anchoredPosition = new Vector2(component2.anchoredPosition.x, num3 - 12f - 110f);
				((Transform)component).localScale = Vector3.one;
				GameObject val14 = Object.Instantiate<GameObject>(((Component)val10).gameObject, val13.transform);
				((Object)val14).name = "Backer";
				PlaceChild(val14, Vector2.zero, (Vector2?)new Vector2(num, 220f));
				Image component3 = val14.GetComponent<Image>();
				if ((Object)(object)component3 != (Object)null)
				{
					((Graphic)component3).raycastTarget = false;
				}
				GameObject val15 = Object.Instantiate<GameObject>(((Component)val7).gameObject, val13.transform);
				((Object)val15).name = "Worm AI Header";
				StripLocalizers(val15);
				PlaceChild(val15, new Vector2(0f, 72f), null);
				SetFirstLabel(val15, "Worm AI");
				GameObject val16 = Object.Instantiate<GameObject>(((Component)val4).gameObject, val13.transform);
				((Object)val16).name = "Enable Worm AI Group";
				StripLocalizers(val16);
				RemoveChild(val16.transform, "Sub Label");
				PlaceChild(val16, new Vector2(0f, 5f), null);
				SetFirstLabel(val16, "Enable AI Worm");
				Transform val17 = val16.transform.Find("Toggle Button (ITS A BUTTON, Toggles are dumb)");
				Button val18 = (((Object)(object)val17 != (Object)null) ? ((Component)val17).GetComponent<Button>() : null);
				Transform val19 = (((Object)(object)val17 != (Object)null) ? val17.Find("Checkmark") : null);
				GameObject checkmark = (((Object)(object)val19 != (Object)null) ? ((Component)val19).gameObject : null);
				if ((Object)(object)val18 == (Object)null)
				{
					throw new InvalidOperationException("cloned toggle button not found");
				}
				val18.onClick = new ButtonClickedEvent();
				val16.AddComponent<LobbyAiToggleBinding>().Initialize(val18, checkmark);
				string text = RelativePath(val12, val11.transform);
				GameObject val20 = RefGameObject(val, "wormAbilityCooldownMultiplier_CustomSettingsGroup");
				string text2 = (((Object)(object)val20 != (Object)null) ? RelativePath(val12, val20.transform) : null);
				GameObject val21 = Object.Instantiate<GameObject>(((Component)val12).gameObject, val13.transform);
				((Object)val21).name = "Worm AI Difficulty Group";
				StripLocalizers(val21);
				if (text2 != null)
				{
					RemoveChild(val21.transform, text2);
				}
				PlaceChild(val21, new Vector2(0f, -63f), null);
				Transform val22 = ((text != null) ? val21.transform.Find(text) : null);
				Component val23 = (((Object)(object)val22 != (Object)null) ? ((Component)val22).GetComponent(((object)val11).GetType()) : null);
				SetFirstLabelExcept(val21, val23, "Difficulty");
				Button[] componentsInChildren = val21.GetComponentsInChildren<Button>(false);
				if ((Object)(object)val23 == (Object)null || componentsInChildren.Length < 2)
				{
					throw new InvalidOperationException("cloned difficulty controls not found");
				}
				Array.Sort(componentsInChildren, (Button left, Button right) => ((Component)left).transform.position.x.CompareTo(((Component)right).transform.position.x));
				Button[] array = componentsInChildren;
				for (int num4 = 0; num4 < array.Length; num4++)
				{
					array[num4].onClick = new ButtonClickedEvent();
				}
				val21.AddComponent<LobbyAiDifficultyBinding>().Initialize(componentsInChildren[0], componentsInChildren[^1], val23);
				val14.transform.SetAsFirstSibling();
				val15.transform.SetSiblingIndex(1);
				val16.transform.SetAsLastSibling();
				val21.transform.SetAsLastSibling();
				val13.transform.SetAsLastSibling();
				val13.SetActive(true);
				Plugin.log.LogInfo((object)($"[ai-toggle] added Worm AI panel at {component.anchoredPosition} " + "using '" + ((Object)val10).name + "'"));
			}
			catch
			{
				if ((Object)(object)val13 != (Object)null)
				{
					Object.Destroy((Object)(object)val13);
				}
				throw;
			}
		}

		private static Transform FindMapGroup(MatchSettingsManager manager)
		{
			GameObject val = RefGameObject(manager, "cactusFruits_CustomSettingsGroup");
			Transform val2 = (((Object)(object)val != (Object)null) ? val.transform.parent : null);
			if (!((Object)(object)val2 != (Object)null))
			{
				return null;
			}
			return val2.parent;
		}

		private static Transform FindDirectChildAncestor(Transform child, Transform parent)
		{
			Transform val = child;
			while ((Object)(object)val != (Object)null && (Object)(object)val.parent != (Object)(object)parent)
			{
				val = val.parent;
			}
			if (!((Object)(object)val != (Object)null) || !((Object)(object)val.parent == (Object)(object)parent))
			{
				return null;
			}
			return val;
		}

		private static string RelativePath(Transform root, Transform child)
		{
			List<string> list = new List<string>();
			Transform val = child;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)root)
			{
				list.Add(((Object)val).name);
				val = val.parent;
			}
			if ((Object)(object)val != (Object)(object)root)
			{
				return null;
			}
			list.Reverse();
			return string.Join("/", list.ToArray());
		}

		private static void PlaceChild(GameObject child, Vector2 position, Vector2? size)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			child.SetActive(true);
			RectTransform component = child.GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null))
			{
				component.anchorMin = new Vector2(0.5f, 0.5f);
				component.anchorMax = new Vector2(0.5f, 0.5f);
				component.pivot = new Vector2(0.5f, 0.5f);
				if (size.HasValue)
				{
					component.sizeDelta = size.Value;
				}
				component.anchoredPosition = position;
				((Transform)component).localScale = Vector3.one;
			}
		}

		private static void RemoveChild(Transform parent, string child_name)
		{
			Transform val = parent.Find(child_name);
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(false);
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
		}

		private static void StripLocalizers(GameObject root)
		{
			Component[] componentsInChildren = root.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string name = ((object)val).GetType().Name;
					if (name.Contains("Localize") || name.Contains("Localizer"))
					{
						Object.Destroy((Object)(object)val);
					}
				}
			}
		}

		private static GameObject RefGameObject(object instance, string field_name)
		{
			FieldInfo field = instance.GetType().GetField(field_name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null)
			{
				return null;
			}
			object value = field.GetValue(instance);
			object obj = ((value is GameObject) ? value : null);
			if (obj == null)
			{
				object obj2 = ((value is Component) ? value : null);
				if (obj2 == null)
				{
					return null;
				}
				obj = ((Component)obj2).gameObject;
			}
			return (GameObject)obj;
		}

		private static Component RefComponent(object instance, string field_name)
		{
			if (instance == null)
			{
				return null;
			}
			FieldInfo field = instance.GetType().GetField(field_name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(field != null))
			{
				return null;
			}
			object? value = field.GetValue(instance);
			return (Component)((value is Component) ? value : null);
		}

		private static void SetFirstLabel(GameObject root, string text)
		{
			Component[] componentsInChildren = root.GetComponentsInChildren<Component>(false);
			foreach (Component val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string name = ((object)val).GetType().Name;
				if (!(name != "TextMeshProUGUI") || !(name != "TMP_Text"))
				{
					PropertyInfo property = ((object)val).GetType().GetProperty("text");
					if (property != null)
					{
						property.SetValue(val, text, null);
					}
					break;
				}
			}
		}

		private static void SetFirstLabelExcept(GameObject root, Component excluded, string text)
		{
			Component[] componentsInChildren = root.GetComponentsInChildren<Component>(false);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)excluded) && !((Object)(object)val.GetComponentInParent<Button>() != (Object)null))
				{
					string name = ((object)val).GetType().Name;
					if (!(name != "TextMeshProUGUI") || !(name != "TMP_Text"))
					{
						SetText(val, text);
						break;
					}
				}
			}
		}

		public static void SetText(Component label, string text)
		{
			if (!((Object)(object)label == (Object)null))
			{
				PropertyInfo property = ((object)label).GetType().GetProperty("text");
				if (property != null)
				{
					property.SetValue(label, text, null);
				}
			}
		}
	}
	public class LobbyAiToggleBinding : MonoBehaviour
	{
		private Button button;

		private GameObject mark;

		public void Initialize(Button toggle_button, GameObject checkmark)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			button = toggle_button;
			mark = checkmark;
			((UnityEvent)button.onClick).AddListener(new UnityAction(OnClicked));
			Refresh();
		}

		private void Update()
		{
			Refresh();
		}

		private void OnClicked()
		{
			LobbyAiState.SetLocalEnabled(!Settings.ai_enabled);
			Refresh();
		}

		private void Refresh()
		{
			if ((Object)(object)button != (Object)null)
			{
				((Selectable)button).interactable = true;
			}
			if ((Object)(object)mark != (Object)null && mark.activeSelf != Settings.ai_enabled)
			{
				mark.SetActive(Settings.ai_enabled);
			}
		}
	}
	public class LobbyAiDifficultyBinding : MonoBehaviour
	{
		private Button previous_button;

		private Button next_button;

		private Component value_label;

		public void Initialize(Button previous, Button next, Component label)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			previous_button = previous;
			next_button = next;
			value_label = label;
			((UnityEvent)previous_button.onClick).AddListener(new UnityAction(Previous));
			((UnityEvent)next_button.onClick).AddListener(new UnityAction(Next));
			Refresh();
		}

		private void Update()
		{
			Refresh();
		}

		private void Previous()
		{
			LobbyAiState.SetLocalDifficulty(AiWormDifficultyRules.Clamp((int)(Settings.ai_difficulty - 1)));
			Refresh();
		}

		private void Next()
		{
			LobbyAiState.SetLocalDifficulty(AiWormDifficultyRules.Clamp((int)(Settings.ai_difficulty + 1)));
			Refresh();
		}

		private void Refresh()
		{
			if ((Object)(object)previous_button != (Object)null)
			{
				((Selectable)previous_button).interactable = (int)Settings.ai_difficulty > 0;
			}
			if ((Object)(object)next_button != (Object)null)
			{
				((Selectable)next_button).interactable = (int)Settings.ai_difficulty < 2;
			}
			LobbySettingsUI.SetText(value_label, AiWormDifficultyRules.DisplayName(Settings.ai_difficulty));
		}
	}
	public static class ObservationBuilder
	{
		public const int SCHEMA_VERSION = 1;

		public const float WORLD_CLAMP = 255f;

		private const int N_PARDNERS = 4;

		private const int N_OBJECTIVES = 4;

		private const int N_ABILITIES = 4;

		private const int ROCK_K = 4;

		public const int OBS_SIZE = 93;

		public static float[] Build(WormMovement worm)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			List<float> list = new List<float>(93);
			Transform transform = ((Component)worm).transform;
			Vector3 val = Vector3.zero;
			Rigidbody component = ((Component)worm).GetComponent<Rigidbody>();
			if ((Object)(object)component != (Object)null)
			{
				val = component.velocity;
			}
			Vector3 forward = transform.forward;
			float num = Mathf.Atan2(forward.z, forward.x);
			list.Add(0f);
			AddOneHot(list, 0, 5);
			list.Add(val.x / 100f);
			list.Add(val.z / 100f);
			list.Add(Mathf.Sin(num));
			list.Add(Mathf.Cos(num));
			list.Add(1f);
			list.Add(1f);
			list.Add(1f);
			list.Add(0f);
			list.Add(0f);
			list.Add(0f);
			for (int i = 0; i < 4; i++)
			{
				list.Add(1f);
				list.Add(1f);
			}
			List<Transform> list2 = NearestPardners(transform.position, 4);
			for (int j = 0; j < 4; j++)
			{
				if (j < list2.Count)
				{
					Vector3 val2 = (list2[j].position - transform.position) / 255f;
					list.Add(val2.x);
					list.Add(val2.z);
					list.Add(0f);
					list.Add(0f);
					list.Add(1f);
					list.Add(0f);
					list.Add(val2.x);
					list.Add(val2.z);
					list.Add(1f);
				}
				else
				{
					list.Add(0f);
					list.Add(0f);
					list.Add(0f);
					list.Add(0f);
					list.Add(0f);
					list.Add(1f);
					list.Add(0f);
					list.Add(0f);
					list.Add(0f);
				}
			}
			for (int k = 0; k < 4; k++)
			{
				list.Add(0f);
				list.Add(0f);
				list.Add(0f);
				list.Add(0f);
				list.Add(0f);
			}
			list.Add(0f);
			list.Add(0f);
			list.Add(0f);
			list.Add(0f);
			list.Add(1f);
			for (int l = 0; l < 4; l++)
			{
				list.Add(0f);
				list.Add(0f);
			}
			if (list.Count != 93)
			{
				Plugin.log.LogError((object)$"obs size {list.Count} != {93} - schema mismatch!");
			}
			return list.ToArray();
		}

		private static List<Transform> NearestPardners(Vector3 from, int k)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			List<(float, Transform)> list = new List<(float, Transform)>();
			Player[] array = Object.FindObjectsOfType<Player>();
			foreach (Player val in array)
			{
				bool flag;
				try
				{
					flag = Traverse.Create((object)val).Field("isAlive").GetValue<bool>();
				}
				catch
				{
					flag = true;
				}
				if (flag)
				{
					Vector3 val2 = ((Component)val).transform.position - from;
					list.Add((((Vector3)(ref val2)).sqrMagnitude, ((Component)val).transform));
				}
			}
			list.Sort(((float d, Transform t) a, (float d, Transform t) b) => a.d.CompareTo(b.d));
			List<Transform> list2 = new List<Transform>();
			for (int num = 0; num < k && num < list.Count; num++)
			{
				list2.Add(list[num].Item2);
			}
			return list2;
		}

		private static void AddOneHot(List<float> o, int idx, int n)
		{
			for (int i = 0; i < n; i++)
			{
				o.Add((i == idx) ? 1f : 0f);
			}
		}
	}
	public struct WormAction
	{
		public float move_x;

		public float move_y;

		public bool dive;

		public bool burrow;

		public bool brakes;

		public bool[] abilities;
	}
	public class OnnxWormPolicy
	{
		public bool ready;

		private InferenceSession session;

		private readonly int obs_dim;

		private readonly int n_buttons;

		public OnnxWormPolicy(string model_path, int obs_dim = 93, int n_buttons = 7)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			this.obs_dim = obs_dim;
			this.n_buttons = n_buttons;
			try
			{
				session = new InferenceSession(model_path);
				ready = true;
			}
			catch (Exception ex)
			{
				Plugin.log.LogWarning((object)("onnx load failed: " + ex.Message));
				ready = false;
			}
		}

		public WormAction Act(float[] obs)
		{
			DenseTensor<float> val = new DenseTensor<float>((Memory<float>)obs, (ReadOnlySpan<int>)new int[2] { 1, obs_dim }, false);
			List<NamedOnnxValue> list = new List<NamedOnnxValue> { NamedOnnxValue.CreateFromTensor<float>("obs", (Tensor<float>)(object)val) };
			IDisposableReadOnlyCollection<DisposableNamedOnnxValue> val2 = session.Run((IReadOnlyCollection<NamedOnnxValue>)list);
			try
			{
				float[] array = null;
				float[] array2 = null;
				foreach (DisposableNamedOnnxValue item in (IEnumerable<DisposableNamedOnnxValue>)val2)
				{
					if (((NamedOnnxValue)item).Name == "move")
					{
						array = ((IEnumerable<float>)((NamedOnnxValue)item).AsTensor<float>()).ToArray();
					}
					else if (((NamedOnnxValue)item).Name == "button_probs")
					{
						array2 = ((IEnumerable<float>)((NamedOnnxValue)item).AsTensor<float>()).ToArray();
					}
				}
				bool[] array3 = new bool[n_buttons - 3];
				for (int i = 0; i < array3.Length; i++)
				{
					array3[i] = array2[3 + i] > 0.5f;
				}
				return new WormAction
				{
					move_x = array[0],
					move_y = array[1],
					dive = (array2[0] > 0.5f),
					burrow = (array2[1] > 0.5f),
					brakes = (array2[2] > 0.5f),
					abilities = array3
				};
			}
			finally
			{
				((IDisposable)val2)?.Dispose();
			}
		}
	}
	[BepInPlugin("com.wormtown.ai", "WormtownAI", "0.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string GUID = "com.wormtown.ai";

		public const string NAME = "WormtownAI";

		public const string VERSION = "0.1.0";

		public static Plugin instance;

		public static ManualLogSource log;

		public static OnnxWormPolicy policy;

		private static string plugin_directory;

		private static bool policy_load_attempted;

		private ConfigEntry<bool> ai_enabled_config;

		private ConfigEntry<AiWormDifficulty> ai_difficulty_config;

		[DllImport("kernel32", CharSet = CharSet.Unicode, SetLastError = true)]
		private static extern bool SetDllDirectory(string path);

		private void Awake()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			instance = this;
			log = ((BaseUnityPlugin)this).Logger;
			plugin_directory = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			BindConfig();
			Harmony val = new Harmony("com.wormtown.ai");
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			foreach (Type type in types)
			{
				try
				{
					val.CreateClassProcessor(type).Patch();
				}
				catch (Exception ex)
				{
					log.LogWarning((object)("patch class " + type.Name + " failed: " + ex.Message));
				}
			}
			log.LogInfo((object)"WormtownAI 0.1.0 loaded");
		}

		public static void EnsurePolicyLoaded()
		{
			if (!policy_load_attempted && LobbyAiState.IsLocalHost && !string.IsNullOrEmpty(plugin_directory))
			{
				policy_load_attempted = true;
				try
				{
					SetDllDirectory(plugin_directory);
				}
				catch
				{
				}
				string text = Path.Combine(plugin_directory, "worm_policy.onnx");
				policy = new OnnxWormPolicy(text);
				try
				{
					SetDllDirectory(null);
				}
				catch
				{
				}
				log.LogInfo((object)("policy: " + (policy.ready ? ("loaded " + text) : "NOT loaded (scripted fallback active)")));
			}
		}

		public static void SaveLocalPreferences()
		{
			if (!((Object)(object)instance == (Object)null))
			{
				instance.ai_enabled_config.Value = Settings.ai_enabled;
				instance.ai_difficulty_config.Value = Settings.ai_difficulty;
			}
		}

		private void BindConfig()
		{
			ai_enabled_config = ((BaseUnityPlugin)this).Config.Bind<bool>("AI", "ClientEnabled", false, "Request one AI worm for this player. Default off; enable via the lobby toggle.");
			ai_difficulty_config = ((BaseUnityPlugin)this).Config.Bind<AiWormDifficulty>("AI", "ClientDifficulty", AiWormDifficulty.Garden, "Difficulty for this player's requested AI worm.");
			LobbyAiState.Initialize(ai_enabled_config.Value, AiWormDifficultyRules.Clamp((int)ai_difficulty_config.Value));
			Settings.debug_scripted = ((BaseUnityPlugin)this).Config.Bind<bool>("AI", "ForceScripted", false, "Ignore the ONNX model and drive the worm with a simple scripted policy.").Value;
		}
	}
	public static class Settings
	{
		public static bool ai_enabled;

		public static AiWormDifficulty ai_difficulty;

		public static bool debug_scripted;
	}
	[HarmonyPatch]
	public static class StartPatches
	{
		[HarmonyPatch(typeof(LobbyManager), "AttemptToStartGame")]
		[HarmonyPrefix]
		public static bool AttemptToStartGame_Prefix(LobbyManager __instance, ref bool force)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			MenuToGameBridger singleton2 = MenuToGameBridger.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsHost || (Object)(object)singleton2 == (Object)null || singleton2.isWormTutorial || singleton2.isPardnerTutorial)
			{
				return true;
			}
			if (LobbyAiState.IsHostEnabled)
			{
				TeamPatches.EnsureEnabledPlayersArePardners();
				if (!TeamPatches.AreEnabledPlayersOnPardnerTeam(__instance))
				{
					return false;
				}
				AiWormManager.CaptureStartRoster();
				LobbyAiState.EnsureAiLoadout();
				if (singleton2.isQuickplayMatch)
				{
					return true;
				}
				force = true;
				return true;
			}
			AiWormManager.ClearStartRoster();
			if (force && (__instance.wormTeam == null || __instance.wormTeam.Count == 0))
			{
				try
				{
					Traverse.Create((object)__instance).Method("ShowNeedAtLeastOneWormPlayer_ServerRPC", Array.Empty<object>()).GetValue();
				}
				catch
				{
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	public static class TeamPatches
	{
		private static readonly HashSet<ulong> assigned_clients = new HashSet<ulong>();

		private static float next_assignment_attempt;

		private static LobbyManager assigned_lobby;

		public static void ResetAssignments()
		{
			assigned_clients.Clear();
			next_assignment_attempt = 0f;
			assigned_lobby = null;
		}

		[HarmonyPatch(typeof(LobbyManager), "ChooseWormTeamButtonClick", new Type[] { })]
		[HarmonyPrefix]
		public static bool ChooseWormTeamButtonClick_Prefix(LobbyManager __instance)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !ShouldRestrictClient(__instance, singleton.LocalClientId))
			{
				return true;
			}
			__instance.ChooseHumanTeamButtonClick();
			Plugin.log.LogInfo((object)"[ai-worm] routed enabled player to pardner team");
			return false;
		}

		[HarmonyPatch(typeof(LobbyManager), "RequestToJoinATeam_ServerRPC", new Type[]
		{
			typeof(ulong),
			typeof(int)
		})]
		[HarmonyPrefix]
		public static void RequestToJoinATeam_Prefix(LobbyManager __instance, ulong _clientID, ref int _teamIndex)
		{
			if (_teamIndex == 0 && ShouldRestrictClient(__instance, _clientID))
			{
				_teamIndex = 1;
			}
		}

		[HarmonyPatch(typeof(LobbyManager), "AddPlayerToTeam", new Type[]
		{
			typeof(ulong),
			typeof(int)
		})]
		[HarmonyPrefix]
		public static void AddPlayerToTeam_Prefix(LobbyManager __instance, ulong _clientID, ref int teamIndex)
		{
			if (teamIndex == 0 && ShouldRestrictClient(__instance, _clientID))
			{
				teamIndex = 1;
			}
		}

		[HarmonyPatch(typeof(LobbyManager), "SwitchTeamButton", new Type[] { })]
		[HarmonyPrefix]
		public static bool SwitchTeamButton_Prefix(LobbyManager __instance)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !ShouldRestrictClient(__instance, singleton.LocalClientId) || !singleton.ConnectedClients.TryGetValue(singleton.LocalClientId, out var value))
			{
				return true;
			}
			if (__instance.humanTeam != null && __instance.humanTeam.Contains(value))
			{
				Plugin.log.LogInfo((object)"[ai-worm] blocked enabled player worm-team switch");
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(LobbyManager), "SwitchTeams_ServerRPC", new Type[]
		{
			typeof(ulong),
			typeof(ServerRpcParams)
		})]
		[HarmonyPrefix]
		public static bool SwitchTeams_ServerRPC_Prefix(LobbyManager __instance, ulong _clientID)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !ShouldRestrictClient(__instance, _clientID) || !singleton.ConnectedClients.TryGetValue(_clientID, out var value))
			{
				return true;
			}
			if (__instance.humanTeam != null)
			{
				return !__instance.humanTeam.Contains(value);
			}
			return true;
		}

		public static void EnsureEnabledPlayersArePardners()
		{
			LobbyManager singleton = LobbyManager.Singleton;
			NetworkManager singleton2 = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || (Object)(object)singleton2 == (Object)null || !singleton2.IsHost || !LobbyAiState.IsHostEnabled || !IsNormalPregame(singleton) || singleton.humanTeam == null || singleton.wormTeam == null)
			{
				return;
			}
			if ((Object)(object)assigned_lobby != (Object)(object)singleton)
			{
				assigned_clients.Clear();
				next_assignment_attempt = 0f;
				assigned_lobby = singleton;
			}
			bool flag = false;
			foreach (ulong requiredPardnerClientId in GetRequiredPardnerClientIds())
			{
				if (singleton2.ConnectedClients.TryGetValue(requiredPardnerClientId, out var value))
				{
					bool flag2 = singleton.humanTeam.Contains(value);
					bool flag3 = singleton.wormTeam.Contains(value);
					bool flag4 = singleton.spectatorTeam != null && singleton.spectatorTeam.Contains(value);
					if (!assigned_clients.Contains(requiredPardnerClientId) || !flag2 || flag3 || flag4)
					{
						flag = true;
						break;
					}
				}
			}
			if (!flag || Time.unscaledTime < next_assignment_attempt)
			{
				return;
			}
			next_assignment_attempt = Time.unscaledTime + 1f;
			bool flag5 = false;
			foreach (ulong requiredPardnerClientId2 in GetRequiredPardnerClientIds())
			{
				if (!singleton2.ConnectedClients.TryGetValue(requiredPardnerClientId2, out var value2))
				{
					continue;
				}
				bool flag6 = singleton.humanTeam.Contains(value2);
				bool flag7 = singleton.wormTeam.Contains(value2);
				bool flag8 = singleton.spectatorTeam != null && singleton.spectatorTeam.Contains(value2);
				if (assigned_clients.Contains(requiredPardnerClientId2) && flag6 && !flag7 && !flag8)
				{
					continue;
				}
				try
				{
					singleton.wormTeam.Remove(value2);
					if (singleton.spectatorTeam != null)
					{
						singleton.spectatorTeam.Remove(value2);
					}
					if (singleton.readiedPlayers != null)
					{
						singleton.readiedPlayers.Remove(value2);
					}
					Traverse.Create((object)singleton).Method("AddPlayerToTeam", new object[2] { requiredPardnerClientId2, 1 }).GetValue();
					Traverse.Create((object)singleton).Method("MovePlayerDummyToTheirCorrectSpotAboveGround_ServerRPC", new object[1] { requiredPardnerClientId2 }).GetValue();
					assigned_clients.Add(requiredPardnerClientId2);
					flag5 = true;
					Plugin.log.LogInfo((object)$"[ai-worm] assigned enabled client {requiredPardnerClientId2} to pardner team");
				}
				catch (Exception ex)
				{
					Plugin.log.LogWarning((object)$"[ai-worm] pardner assignment failed for {requiredPardnerClientId2}: {ex.Message}");
				}
			}
			if (flag5)
			{
				singleton.RequestWormDummiesInfoFromServer_ServerRPC();
			}
		}

		public static bool AreEnabledPlayersOnPardnerTeam(LobbyManager lobby)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)lobby == (Object)null || (Object)(object)singleton == (Object)null || !singleton.IsHost || lobby.humanTeam == null || lobby.wormTeam == null)
			{
				return false;
			}
			bool result = false;
			foreach (ulong requiredPardnerClientId in GetRequiredPardnerClientIds())
			{
				result = true;
				if (!singleton.ConnectedClients.TryGetValue(requiredPardnerClientId, out var value) || !lobby.humanTeam.Contains(value) || lobby.wormTeam.Contains(value) || (lobby.spectatorTeam != null && lobby.spectatorTeam.Contains(value)))
				{
					return false;
				}
			}
			return result;
		}

		private static bool IsNormalPregame(LobbyManager lobby)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			MenuToGameBridger singleton = MenuToGameBridger.Singleton;
			if ((Object)(object)lobby != (Object)null && (Object)(object)GameManager.Singleton != (Object)null && (int)GameManager.Singleton.gameState == 0)
			{
				if (!((Object)(object)singleton == (Object)null))
				{
					if (!singleton.isWormTutorial)
					{
						return !singleton.isPardnerTutorial;
					}
					return false;
				}
				return true;
			}
			return false;
		}

		private static IEnumerable<ulong> GetRequiredPardnerClientIds()
		{
			NetworkManager manager = NetworkManager.Singleton;
			if ((Object)(object)manager == (Object)null || !manager.IsHost || !LobbyAiState.IsHostEnabled)
			{
				yield break;
			}
			yield return manager.LocalClientId;
			foreach (ulong enabledClientId in LobbyAiState.GetEnabledClientIds())
			{
				if (enabledClientId != manager.LocalClientId)
				{
					yield return enabledClientId;
				}
			}
		}

		private static bool ShouldRestrictClient(LobbyManager lobby, ulong client_id)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			bool flag = (Object)(object)singleton != (Object)null && singleton.IsHost && client_id == singleton.LocalClientId && LobbyAiState.IsHostEnabled;
			if ((Object)(object)singleton != (Object)null && IsNormalPregame(lobby))
			{
				if (!flag)
				{
					return LobbyAiState.IsClientEnabled(client_id);
				}
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch]
	public static class VisualPatches
	{
		[HarmonyPatch(typeof(InGameWormCosmeticBuilder), "HideFirstPersonWormMouth_SettingChanged")]
		[HarmonyPrefix]
		public static bool HideFirstPersonWormMouth_Prefix(InGameWormCosmeticBuilder __instance)
		{
			return !AiWormManager.IsAiWorm((Component)(object)__instance);
		}

		[HarmonyPatch(typeof(InGameWormCosmeticBuilder), "CreateCosmetics")]
		[HarmonyPostfix]
		public static void CreateCosmetics_Postfix(InGameWormCosmeticBuilder __instance)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			if (!AiWormManager.IsAiWorm((Component)(object)__instance))
			{
				return;
			}
			try
			{
				Traverse val = Traverse.Create((object)__instance);
				GameObject value = val.Field("worm_Spawned_Head").GetValue<GameObject>();
				if ((Object)(object)value != (Object)null)
				{
					value.transform.localScale = Vector3.one;
				}
				int num = RestoreCosmetic(value);
				num += RestoreCosmetic(val.Field("worm_Spawned_Eye_Left").GetValue<GameObject>());
				num += RestoreCosmetic(val.Field("worm_Spawned_Eye_Right").GetValue<GameObject>());
				GameObject value2 = val.Field("worm_Spawned_Teeth").GetValue<GameObject>();
				if ((Object)(object)value2 != (Object)null)
				{
					value2.transform.localScale = Vector3.one;
				}
				num += RestoreCosmetic(value2);
				num += RestoreCosmetic(val.Field("worm_Spawned_Horn").GetValue<GameObject>());
				num += RestoreCosmetic(val.Field("worm_Spawned_Hat").GetValue<GameObject>());
				List<GameObject> value3 = val.Field("worm_Spawned_BodySegments").GetValue<List<GameObject>>();
				if (value3 != null)
				{
					foreach (GameObject item in value3)
					{
						num += RestoreCosmetic(item);
					}
				}
				Plugin.log.LogInfo((object)$"[worm] restored {num} cosmetic renderer(s)");
			}
			catch (Exception ex)
			{
				Plugin.log.LogWarning((object)("[worm] cosmetic visibility failed: " + ex.Message));
			}
		}

		private static int RestoreCosmetic(GameObject cosmetic)
		{
			if ((Object)(object)cosmetic == (Object)null)
			{
				return 0;
			}
			cosmetic.SetActive(true);
			WormCustomizerAccessory component = cosmetic.GetComponent<WormCustomizerAccessory>();
			if ((Object)(object)component != (Object)null && component.hideIfWereTheOwner != null)
			{
				foreach (GameObject item in component.hideIfWereTheOwner)
				{
					if ((Object)(object)item != (Object)null)
					{
						item.SetActive(true);
					}
				}
			}
			int num = 0;
			Renderer[] componentsInChildren = cosmetic.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					val.enabled = true;
					val.shadowCastingMode = (ShadowCastingMode)1;
					num++;
				}
			}
			return num;
		}

		[HarmonyPatch(typeof(WormCameraSpeedEffectsHandler), "ShowSpeedLines")]
		[HarmonyPrefix]
		public static bool ShowSpeedLines_Prefix()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Invalid comparison between Unknown and I4
			if (AiWormManager.ai_worms.Count > 0 && (Object)(object)GameManager.Singleton != (Object)null && (int)GameManager.Singleton.playerType != 1)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(WormPlayer), "DamageWorm")]
		[HarmonyPrefix]
		public static bool DamageWorm_Prefix(WormPlayer __instance, int _damage)
		{
			if (AiWormManager.IsAiWorm((Component)(object)__instance))
			{
				__instance.wormHealth -= (float)_damage;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	public static class WormActionInjector
	{
		private static bool logged_move_error;

		[HarmonyPatch(typeof(WormMovement), "FixedUpdate")]
		[HarmonyPrefix]
		public static void FixedUpdate_Prefix(WormMovement __instance)
		{
			if (WormAiController.ShouldControl(__instance))
			{
				WormAiController.DisableWormInput();
				WormAiController.Tick(__instance);
				OverwriteMove(__instance);
			}
		}

		[HarmonyPatch(typeof(WormMovement), "CalculateMovement")]
		[HarmonyPostfix]
		public static void CalculateMovement_Postfix(WormMovement __instance)
		{
			OverwriteMove(__instance);
		}

		[HarmonyPatch(typeof(WormMovement), "CalculateMovement_FreeMoveBurrowed")]
		[HarmonyPostfix]
		public static void CalculateMovementBurrowed_Postfix(WormMovement __instance)
		{
			OverwriteMove(__instance);
		}

		private static void OverwriteMove(WormMovement worm)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!WormAiController.ShouldControl(worm))
			{
				return;
			}
			try
			{
				Vector3 val = WormAiController.MoveDir(worm);
				Traverse.Create((object)worm).Field("moveVector").SetValue((object)val);
			}
			catch (Exception ex)
			{
				if (!logged_move_error)
				{
					logged_move_error = true;
					Plugin.log.LogWarning((object)("moveVector injection failed (logged once): " + ex.Message));
				}
			}
		}

		[HarmonyPatch(typeof(WormMovement), "Update")]
		[HarmonyPostfix]
		public static void Update_Postfix(WormMovement __instance)
		{
			if (WormAiController.ShouldControl(__instance))
			{
				WormAiController.DriveDiscreteActions(__instance);
			}
		}
	}
	public static class WormAiController
	{
		private enum PathResult
		{
			Clear,
			Building,
			Blocked
		}

		private enum RecoveryPhase
		{
			None,
			Burrow,
			Escape,
			Surface
		}

		private sealed class MoveControllerState
		{
			public float heading_deg;

			public float turn_velocity;

			public float magnitude;

			public float magnitude_velocity;

			public float last_tick;

			public Vector3 output;
		}

		private sealed class NavigationState
		{
			public bool initialized;

			public Vector3 last_pos;

			public float last_tick;

			public float speed_ema;

			public float forward_speed_ema;

			public float low_motion_time;

			public float blocked_time;

			public Vector3 last_requested_dir;

			public Vector3 last_command_dir;

			public float last_command_mag;

			public float direction_grace_until;

			public Vector3 avoid_dir;

			public float avoid_until;

			public float avoid_clear_since;

			public int avoid_side;

			public readonly List<Vector3> path_waypoints = new List<Vector3>();

			public int path_index;

			public Vector3 path_start;

			public Vector3 path_destination;

			public Vector3 path_goal_dir;

			public bool path_has_destination;

			public bool path_burrowed;

			public bool path_include_buildings;

			public float path_created_at;

			public float path_progress_at;

			public float path_best_distance;

			public float path_next_check;

			public float path_next_replan;

			public bool path_has_progress;

			public Vector3 surface_unstick_dir;

			public float surface_unstick_until;

			public RecoveryPhase phase;

			public float phase_started;

			public Vector3 recovery_origin;

			public Vector3 recovery_dir;

			public Vector3 surface_target;

			public float recovery_started;

			public float clear_time;

			public float cooldown_until;

			public bool surface_search;

			public bool has_surface_target;
		}

		private sealed class DiveIntent
		{
			public Player target;

			public float created_at;

			public bool lob;

			public float lob_apex_height_scale;
		}

		private struct DiveSolution
		{
			public Vector3 aim_dir;

			public Vector3 target_pos;

			public float flight_time;

			public float miss_distance;

			public float power_scale;
		}

		private sealed class AttackPlan
		{
			public Player target;

			public Vector3 launch_pos;

			public Vector3 setup_pos;

			public bool attack_run;

			public bool setup_reached;

			public bool launch_reached;

			public bool lob;

			public float lob_apex_height_scale;

			public float launch_distance;

			public float expires_at;
		}

		private sealed class AttackSearchState
		{
			public Player target;

			public float started_at;

			public float expires_at;

			public bool lob;

			public float lob_apex_height_scale;
		}

		private sealed class RangeApproachState
		{
			public float best_distance;

			public float last_progress_at;
		}

		private sealed class AttackPressureState
		{
			public Player target;

			public float near_since = -1f;

			public float forcing_since = -1f;
		}

		private sealed class LostSightAbilityState
		{
			public Player target;

			public bool was_visible;

			public bool pending;

			public int queued_slot = -1;
		}

		private static readonly Dictionary<WormMovement, WormAction> actions = new Dictionary<WormMovement, WormAction>();

		private static readonly Dictionary<WormMovement, bool> prev_burrow = new Dictionary<WormMovement, bool>();

		private static readonly Dictionary<WormMovement, bool[]> prev_abilities = new Dictionary<WormMovement, bool[]>();

		private static readonly Dictionary<WormMovement, float> next_unburrow = new Dictionary<WormMovement, float>();

		private static readonly Dictionary<WormMovement, bool> desired_burrowed = new Dictionary<WormMovement, bool>();

		private static readonly Dictionary<WormMovement, Vector3> flee_dir = new Dictionary<WormMovement, Vector3>();

		private static readonly Dictionary<Player, Vector3> pardner_pos = new Dictionary<Player, Vector3>();

		private static readonly Dictionary<Player, Vector3> pardner_vel = new Dictionary<Player, Vector3>();

		private static readonly Dictionary<WormMovement, float> surfaced_time = new Dictionary<WormMovement, float>();

		private static readonly Dictionary<WormMovement, MoveControllerState> move_controllers = new Dictionary<WormMovement, MoveControllerState>();

		private static readonly Dictionary<WormMovement, NavigationState> navigation_states = new Dictionary<WormMovement, NavigationState>();

		private static readonly Dictionary<WormMovement, Vector3> committed_dive_dir = new Dictionary<WormMovement, Vector3>();

		private static readonly Dictionary<WormMovement, Player> committed_dive_target = new Dictionary<WormMovement, Player>();

		private static readonly HashSet<WormMovement> committed_lob_dives = new HashSet<WormMovement>();

		private static readonly Dictionary<WormMovement, AudioListener> worm_listener = new Dictionary<WormMovement, AudioListener>();

		private static readonly Dictionary<WormMovement, float> dive_homing_initial_distance = new Dictionary<WormMovement, float>();

		private static readonly Dictionary<WormMovement, DiveIntent> dive_intents = new Dictionary<WormMovement, DiveIntent>();

		private static readonly Dictionary<WormMovement, DiveIntent> committed_attack_runs = new Dictionary<WormMovement, DiveIntent>();

		private static readonly Dictionary<WormMovement, float> attack_run_retry_at = new Dictionary<WormMovement, float>();

		private static readonly Dictionary<WormMovement, AttackPlan> attack_plans = new Dictionary<WormMovement, AttackPlan>();

		private static readonly Dictionary<WormMovement, float> attack_spot_retry = new Dictionary<WormMovement, float>();

		private static readonly Dictionary<WormMovement, AttackSearchState> attack_searches = new Dictionary<WormMovement, AttackSearchState>();

		private static readonly Dictionary<WormMovement, AttackPressureState> attack_pressure = new Dictionary<WormMovement, AttackPressureState>();

		private static readonly Dictionary<WormMovement, float> next_dive_gate_log = new Dictionary<WormMovement, float>();

		private static readonly Dictionary<WormMovement, RangeApproachState> range_burrow_approach = new Dictionary<WormMovement, RangeApproachState>();

		private static readonly Dictionary<WormMovement, float> range_burrow_retry_at = new Dictionary<WormMovement, float>();

		private static readonly HashSet<WormMovement> attack_backoff = new HashSet<WormMovement>();

		private static readonly Dictionary<WormMovement, Vector3> attack_backoff_dir = new Dictionary<WormMovement, Vector3>();

		private static readonly HashSet<WormMovement> navigation_holds = new HashSet<WormMovement>();

		private static readonly Dictionary<WormMovement, Vector3> navigation_goals = new Dictionary<WormMovement, Vector3>();

		private static readonly HashSet<WormMovement> scripted_control = new HashSet<WormMovement>();

		private static readonly Dictionary<WormMovement, LostSightAbilityState> lost_sight_abilities = new Dictionary<WormMovement, LostSightAbilityState>();

		private static readonly Dictionary<WormMovement, float> snake_next_bile = new Dictionary<WormMovement, float>();

		private static readonly int attack_obstacle_mask = LayerMask.GetMask(new string[4] { "Default", "Environment", "Parts and Debris", "WormOnlyCollide" });

		private static readonly int dive_lane_mask = attack_obstacle_mask | LayerMask.GetMask(new string[2] { "Worm", "WormBody" });

		private static readonly int ground_only_mask = LayerMask.GetMask(new string[1] { "Ground" });

		private static readonly Collider[] clearing_overlap_hits = (Collider[])(object)new Collider[64];

		private static readonly RaycastHit[] attack_run_hits = (RaycastHit[])(object)new RaycastHit[64];

		private static readonly RaycastHit[] dive_lane_hits = (RaycastHit[])(object)new RaycastHit[64];

		private static readonly RaycastHit[] navigation_cast_hits = (RaycastHit[])(object)new RaycastHit[64];

		private static readonly Collider[] navigation_overlap_hits = (Collider[])(object)new Collider[64];

		private static readonly RaycastHit[] navigation_path_cast_hits = (RaycastHit[])(object)new RaycastHit[64];

		private static readonly Collider[] navigation_path_overlap_hits = (Collider[])(object)new Collider[64];

		private static readonly float[] navigation_avoid_angles = new float[8] { 0f, 35f, -35f, 70f, -70f, 105f, -105f, 180f };

		private static int navigation_path_search_frame = -1;

		private static float last_vel_time;

		private const float TURN_SMOOTH_TIME = 0.035f;

		private const float TURN_MAX_DEG_PER_SEC = 1800f;

		private const float MAG_SMOOTH_TIME = 0.025f;

		private const float MAG_MAX_PER_SEC = 20f;

		private const float MOVE_CONTROLLER_RESET_GAP = 0.1f;

		private const float MIN_FORWARD_DIVE_SPEED = 6f;

		private const float POINT_BLANK_DIVE_DISTANCE = 5f;

		private const float MIN_DIVE_TARGET_DOT = 0.8f;

		private const float MIN_DIVE_LIVE_AIM_DOT = 0.45f;

		private const float MIN_DIVE_INTERCEPT_DOT = 0.85f;

		private const float MIN_DIVE_BODY_DOT = 0.35f;

		private const float DIVE_INTENT_MAX_AGE = 0.15f;

		private const float LOST_SIGHT_ABILITY_DELAY = 3f;

		private const float DIVE_COMMIT_MAX_RANGE = 50f;

		private const float DIVE_POWER_FALLBACK = 15f;

		private const float DIVE_POWER_MAX_SCALE = 1.75f;

		private const float DIVE_UP_POWER_FALLBACK = 6f;

		private const float DIVE_TARGET_Y_OFFSET = 1f;

		private const float DIVE_HOMING_TURN_DEG = 71.25f;

		private const float DIVE_HOMING_INITIAL_MULTIPLIER = 2f;

		private const float DIVE_HOMING_MIN_TARGET_DOT = 0.7071068f;

		private const float SNAKE_BILE_MIN_INTERVAL = 5f;

		private const float SNAKE_BILE_MAX_INTERVAL = 15f;

		private const float BULL_LOB_APEX_HEIGHT_SCALE = 1f;

		private const float LOB_APEX_MIN_HEIGHT_SCALE = 1.25f;

		private const float LOB_APEX_MAX_HEIGHT_SCALE = 2f;

		private const float LOB_LAUNCH_MAX_DISTANCE = 50f;

		private const float LOB_LAUNCH_RADIUS_STEP = 4f;

		private const float LOB_PLANNED_POWER_SCALE = 1.1f;

		private const float DIVE_LAUNCH_BASE_DISTANCE = 8f;

		private const float DIVE_LAUNCH_PER_HEIGHT = 1.5f;

		private const float DIVE_LAUNCH_MIN_DISTANCE = 5f;

		private const float DIVE_LAUNCH_MAX_DISTANCE = 26f;

		private const float DIVE_LAUNCH_MIN_BAND = 4f;

		private const float DIVE_LAUNCH_MAX_BAND = 6f;

		private const float DIVE_BACKOFF_EXIT_MARGIN = 2f;

		private const float RANGE_BURROW_ENTER_DISTANCE = 45f;

		private const float RANGE_BURROW_EXIT_DISTANCE = 28f;

		private const float RANGE_BURROW_PROGRESS_DISTANCE = 1f;

		private const float RANGE_BURROW_STALL_TIMEOUT = 2f;

		private const float RANGE_BURROW_RETRY_COOLDOWN = 0.75f;

		private const float DIVE_SUPPORT_HEIGHT_MAX = 8f;

		private const float DIVE_ELEVATED_HEIGHT = 1.5f;

		private const float DIVE_ASSUMED_SURFACE_SPEED = 13f;

		private const float DIVE_TRAJECTORY_MIN_TIME = 0.2f;

		private const float DIVE_TRAJECTORY_MAX_TIME = 1.6f;

		private const float DIVE_TRAJECTORY_TIME_STEP = 0.02f;

		private const float DIVE_TARGET_MAX_SPEED = 8f;

		private const float DIVE_TRAJECTORY_RADIUS = 1.05f;

		private const float DIVE_TRAJECTORY_CAPTURE_RADIUS = 1.25f;

		private const float DIVE_TRAJECTORY_GROUND_BUFFER = 0.3f;

		private const float DIVE_TRAJECTORY_GROUND_DELAY = 0.2f;

		private const int DIVE_TRAJECTORY_SEGMENTS = 12;

		private const float REPOSITION_TIMEOUT = 4f;

		private const float ATTACK_SURFACE_TIMEOUT = 2f;

		private const float ATTACK_RUN_TIMEOUT = 3f;

		private const float ATTACK_RUN_RETRY_COOLDOWN = 0.25f;

		private const float ATTACK_SETUP_REACHED = 0.4f;

		private const float ATTACK_LAUNCH_TOLERANCE = 2f;

		private const float ATTACK_LAUNCH_LATERAL_TOLERANCE = 2f;

		private const float ATTACK_LAUNCH_MAX_OVERSHOOT = 5f;

		private const float ATTACK_SETUP_DISTANCE = 10f;

		private const float ATTACK_SPOT_RETRY_TIME = 0.2f;

		private const float BLOCKED_SURFACE_FALLBACK_TIME = 1f;

		private const float ATTACK_PRESSURE_NEAR_DISTANCE = 30f;

		private const float ATTACK_PRESSURE_EXIT_DISTANCE = 36f;

		private const float ATTACK_PRESSURE_DELAY = 10f;

		private const float ATTACK_PRESSURE_WINDUP = 0.45f;

		private const int ATTACK_SPOT_SAMPLES = 8;

		private const float ATTACK_CLEARANCE_MARGIN = 1f;

		private const float ATTACK_CLEARANCE_MIN_RADIUS = 2f;

		private const float ATTACK_CLEARANCE_MAX_RADIUS = 3f;

		private const float ATTACK_CLEARANCE_OVERHEAD = 2f;

		private const float ATTACK_MIN_GROUND_NORMAL_Y = 0.8f;

		private const float ATTACK_MAX_GROUND_DELTA = 1.5f;

		private const float ATTACK_GROUND_CAST_Y = 100f;

		private const float ATTACK_GROUND_CAST_DISTANCE = 400f;

		private const float ATTACK_RUN_CLEARANCE_RADIUS = 1.5f;

		private const int ATTACK_CLEARANCE_SAMPLES = 8;

		private const float NAV_MIN_COMMAND = 0.55f;

		private const float NAV_SPEED_EMA_TIME = 0.25f;

		private const float STUCK_PLANAR_SPEED = 1.25f;

		private const float STUCK_FORWARD_SPEED = 0.75f;

		private const float STUCK_LOW_MOTION_TIME = 1f;

		private const float STUCK_BLOCKED_TIME = 0.75f;

		private const float SURFACE_UNSTICK_TIME = 0.6f;

		private const float TURN_GRACE_TIME = 0.2f;

		private const float OBSTACLE_RADIUS = 1.75f;

		private const float OBSTACLE_PROXIMITY_RADIUS = 3.25f;

		private const float OBSTACLE_PRESSURE_SCORE = 3f;

		private const float OBSTACLE_BASE_LOOKAHEAD = 3f;

		private const float OBSTACLE_SPEED_LOOKAHEAD = 0.3f;

		private const float OBSTACLE_MAX_LOOKAHEAD = 9f;

		private const float OBSTACLE_HARD_DISTANCE = 1.75f;

		private const float AVOID_HOLD_TIME = 0.65f;

		private const float AVOID_CLEAR_TIME = 0.3f;

		private const float AVOID_SIDE_SCORE_TOLERANCE = 1.25f;

		private const float PATH_NODE_SPACING = 4f;

		private const float PATH_CLEARANCE_RADIUS = 2f;

		private const float PATH_GOAL_DISTANCE = 28f;

		private const float PATH_GOAL_DRIFT = 6f;

		private const float PATH_MIN_GROUND_NORMAL_Y = 0.6f;

		private const float PATH_MAX_GROUND_DELTA = 2.5f;

		private const float PATH_WAYPOINT_REACHED = 1.5f;

		private const float PATH_WAYPOINT_PASS_LATERAL = 4f;

		private const float PATH_DIRECTION_REPLAN_DOT = 0.75f;

		private const float PATH_REPLAN_INTERVAL = 0.3f;

		private const float PATH_RECHECK_INTERVAL = 0.15f;

		private const float PATH_REFRESH_TIME = 2.5f;

		private const float PATH_PROGRESS_DISTANCE = 0.5f;

		private const float PATH_PROGRESS_FRESH_TIME = 0.8f;

		private const float PATH_STALL_TIME = 1f;

		private const float PATH_TURN_COST = 0.6f;

		private const float PATH_BACKWARD_COST = 0.75f;

		private const float PATH_ATTACK_EXPIRY_GRACE = 2f;

		private const int PATH_GRID_RADIUS = 8;

		private const int PATH_GRID_WIDTH = 17;

		private const int PATH_MAX_NODES = 289;

		private const int PATH_MAX_EXPANSIONS = 192;

		private const int PATH_GOAL_SEARCH_RADIUS = 2;

		private const float RECOVERY_BURROW_TIMEOUT = 1.5f;

		private const float RECOVERY_MIN_ESCAPE_TIME = 0.4f;

		private const float RECOVERY_ESCAPE_DISTANCE = 6f;

		private const float SURFACE_SEARCH_MIN_TIME = 0.25f;

		private const float SURFACE_SEARCH_DISTANCE = 2f;

		private const float RECOVERY_CLEAR_TIME = 0.25f;

		private const float RECOVERY_ESCAPE_TIMEOUT = 1f;

		private const float RECOVERY_SURFACE_SEARCH_RADIUS = 12f;

		private const float RECOVERY_SURFACE_SEARCH_RADIUS_LATE = 24f;

		private const float RECOVERY_SURFACE_SEARCH_STEP = 4f;

		private const int RECOVERY_SURFACE_SEARCH_SAMPLES = 8;

		private const float RECOVERY_SURFACE_TARGET_REACHED = 0.5f;

		private const float RECOVERY_SURFACE_TARGET_SLOW_RADIUS = 8f;

		private const float RECOVERY_SURFACE_TIMEOUT = 2f;

		private const float RECOVERY_COOLDOWN = 0.75f;

		private const float RECOVERY_SURFACE_RADIUS = 1.25f;

		private static readonly Vector3[] navigation_path_positions = (Vector3[])(object)new Vector3[289];

		private static readonly float[] navigation_path_g = new float[289];

		private static readonly float[] navigation_path_f = new float[289];

		private static readonly int[] navigation_path_parent = new int[289];

		private static readonly byte[] navigation_path_search_state = new byte[289];

		private static readonly byte[] navigation_path_node_state = new byte[289];

		private static readonly byte[] navigation_path_goal_state = new byte[289];

		private static readonly float[] navigation_path_goal_penalty = new float[289];

		private static readonly byte[] navigation_path_edge_state = new byte[1156];

		private static Player[] cached_pardners = (Player[])(object)new Player[0];

		private static int cache_frame = -1000;

		private static bool logged_drive_error;

		private static readonly Dictionary<WormMovement, Renderer[]> renderer_cache = new Dictionary<WormMovement, Renderer[]>();

		private static readonly string[] BODY_KEYS = new string[3] { "wormdefault", "wormhead", "art" };

		private static readonly string[] HIDE_KEYS = new string[6] { "range indicator", "detection range", "push volume", "projectile spawn point", "segmenttarget", "first person" };

		private static readonly Dictionary<WormMovement, string> prev_dive_state = new Dictionary<WormMovement, string>();

		public static Player[] Pardners()
		{
			if (Time.frameCount - cache_frame > 15)
			{
				cache_frame = Time.frameCount;
				cached_pardners = Object.FindObjectsOfType<Player>();
			}
			return cached_pardners;
		}

		public static bool ShouldControl(WormMovement worm)
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton != (Object)null && singleton.IsHost)
			{
				return AiWormManager.IsActiveAiWorm((Component)(object)worm);
			}
			return false;
		}

		public static void DisableWormInput()
		{
			//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)
			try
			{
				WormActionMapActions wormActionMap = InputManager.Singleton.inputActions.WormActionMap;
				((WormActionMapActions)(ref wormActionMap)).Disable();
			}
			catch
			{
			}
		}

		private static bool ContainsAny(string s, string[] keys)
		{
			foreach (string value in keys)
			{
				if (s.Contains(value))
				{
					return true;
				}
			}
			return false;
		}

		private static void ForceVisible(WormMovement worm)
		{
			try
			{
				if (!renderer_cache.TryGetValue(worm, out var value) || value == null)
				{
					value = (Renderer[])(((object)((Component)worm).GetComponentsInChildren<Renderer>(true)) ?? ((object)new Renderer[0]));
					renderer_cache[worm] = value;
				}
				Renderer[] array = value;
				foreach (Renderer val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						string s = ((Object)val).name.ToLowerInvariant();
						if (ContainsAny(s, HIDE_KEYS))
						{
							val.enabled = false;
						}
						else if (ContainsAny(s, BODY_KEYS))
						{
							val.enabled = true;
							val.shadowCastingMode = (ShadowCastingMode)1;
						}
					}
				}
			}
			catch
			{
			}
		}

		public static void Tick(WormMovement worm)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			navigation_goals.Remove(worm);
			ForceVisible(worm);
			KeepWormCamOff(worm);
			UpdatePardnerVel();
			WormPerception.Tick(worm, Pardners());
			TrackDiveEnd(worm);
			ApplyDiveHoming(worm);
			navigation_holds.Remove(worm);
			bool num = Plugin.policy != null && Plugin.policy.ready && !Settings.debug_scripted;
			bool flag = false;
			bool flag2 = attack_plans.ContainsKey(worm) || attack_searches.ContainsKey(worm) || committed_attack_runs.ContainsKey(worm);
			WormAction a;
			if (num && !flag2)
			{
				try
				{
					a = Plugin.policy.Act(ObservationBuilder.Build(worm));
					if (a.dive)
					{
						Player val = WormPerception.SelectTarget(worm, Pardners());
						if ((Object)(object)val != (Object)null && IsAlive(val))
						{
							Vector3 val2 = WormPerception.PerceivedPosition(worm, val) - ((Component)worm).transform.position;
							val2.y = 0f;
							if (((Vector3)(ref val2)).sqrMagnitude <= 2500f)
							{
								GetAttackSearch(worm, val);
							}
						}
						a = Scripted(worm);
						flag = true;
					}
				}
				catch
				{
					a = Scripted(worm);
					flag = true;
				}
			}
			else
			{
				a = Scripted(worm);
				flag = true;
			}
			if (TryApplyAttackPressure(worm, flag, ref a))
			{
				flag = true;
			}
			if (flag)
			{
				scripted_control.Add(worm);
				if (a.abilities != null)
				{
					for (int i = 0; i < a.abilities.Length; i++)
					{
						if (a.abilities[i])
						{
							a.dive = false;
							committed_attack_runs.Remove(worm);
							dive_intents.Remove(worm);
							break;
						}
					}
				}
				if (!a.dive)
				{
					dive_intents.Remove(worm);
				}
			}
			else
			{
				scripted_control.Remove(worm);
				dive_intents.Remove(worm);
				committed_attack_runs.Remove(worm);
				attack_run_retry_at.Remove(worm);
			}
			ApplyNavigation(worm, flag, ref a);
			actions[worm] = a;
			ControlMove(worm, a);
			FaceMoveDir(worm);
			MaintainCommittedDiveAim(worm);
			DebugStatus(worm, a);
		}

		private static void ControlMove(WormMovement worm, WormAction a)
		{
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: 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_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(a.move_x, 0f, a.move_y);
			if (((Vector3)(ref val)).sqrMagnitude > 1f)
			{
				((Vector3)(ref val)).Normalize();
			}
			if (!move_controllers.TryGetValue(worm, out var value))
			{
				value = new MoveControllerState();
				move_controllers[worm] = value;
			}
			float time = Time.time;
			float fixedDeltaTime = Time.fixedDeltaTime;
			float num = Mathf.Clamp01(((Vector3)(ref val)).magnitude);
			if (value.last_tick <= 0f || time - value.last_tick > 0.1f)
			{
				Vector3 val2 = ((num > 0.0001f) ? val : ((Component)worm).transform.forward);
				val2.y = 0f;
				if (((Vector3)(ref val2)).sqrMagnitude < 0.0001f)
				{
					val2 = Vector3.forward;
				}
				value.heading_deg = Mathf.Atan2(val2.x, val2.z) * 57.29578f;
				value.turn_velocity = 0f;
				value.magnitude = num;
				value.magnitude_velocity = 0f;
			}
			else
			{
				if (num > 0.0001f)
				{
					float num2 = Mathf.Atan2(val.x, val.z) * 57.29578f;
					if (value.magnitude < 0.05f)
					{
						value.heading_deg = num2;
						value.turn_velocity = 0f;
					}
					else
					{
						value.heading_deg = Mathf.SmoothDampAngle(value.heading_deg, num2, ref value.turn_velocity, 0.035f, 1800f, fixedDeltaTime);
					}
				}
				else
				{
					value.turn_velocity = 0f;
				}
				value.magnitude = Mathf.SmoothDamp(value.magnitude, num, ref value.magnitude_velocity, 0.025f, 20f, fixedDeltaTime);
			}
			value.magnitude = Mathf.Clamp01(value.magnitude);
			float num3 = 1f;
			if (num > 0.0001f)
			{
				float num4 = Mathf.Atan2(val.x, val.z) * 57.29578f;
				float num5 = Mathf.Abs(Mathf.DeltaAngle(value.heading_deg, num4));
				float num6 = 1f - Mathf.Clamp01(num5 / 120f);
				num3 = Mathf.Lerp(0.15f, 1f, num6);
			}
			value.output = Quaternion.Euler(0f, value.heading_deg, 0f) * Vector3.forward * value.magnitude * num3;
			value.last_tick = time;
		}

		private static void FaceMoveDir(WormMovement worm)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3 val = MoveDir(worm);
				val.y = 0f;
				if (!(((Vector3)(ref val)).sqrMagnitude > 0.0001f))
				{
					return;
				}
				Quaternion val2 = Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.up);
				WormPlayer component = ((Component)worm).GetComponent<WormPlayer>();
				bool flag = scripted_control.Contains(worm) || committed_dive_dir.ContainsKey(worm);
				Quaternion val3 = (((Object)(object)component != (Object)null && (Object)(object)component.wormCam != (Object)null) ? ((Component)component.wormCam).transform.rotation : Quaternion.identity);
				((Component)worm).transform.rotation = val2;
				WormCamLook componentInChildren = ((Component)worm).GetComponentInChildren<WormCamLook>(true);
				if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.wormBody != (Object)null)
				{
					componentInChildren.wormBody.rotation = val2;
				}
				if ((Object)(object)component != (Object)null && (Object)(object)component.wormCam != (Object)null)
				{
					((Component)component.wormCam).transform.rotation = (flag ? val3 : val2);
					if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.wormHeadArt != (Object)null)
					{
						componentInChildren.wormHeadArt.rotation = ((Component)component.wormCam).transform.rotation;
					}
				}
			}
			catch
			{
			}
		}

		private static void DebugStatus(WormMovement worm, WormAction a)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			if (Time.frameCount % 120 != 0)
			{
				return;
			}
			try
			{
				Traverse obj = Traverse.Create((object)((Component)worm).GetComponent<WormPlayer>());
				object value = obj.Field("wormMovementState").GetValue();
				object value2 = obj.Field("wormHealth").GetValue();
				object value3 = obj.Field("wormHealth_Max").GetValue();
				bool value4;
				bool flag = desired_burrowed.TryGetValue(worm, out value4) && value4;
				string arg = "None";
				if (navigation_states.TryGetValue(worm, out var value5))
				{
					arg = ((value5.phase != RecoveryPhase.None) ? value5.phase.ToString() : ((Time.time < value5.surface_unstick_until) ? "SurfaceUnstick" : "None"));
				}
				string arg2 = "None";
				if (attack_plans.TryGetValue(worm, out var value6))
				{
					string text = (value6.attack_run ? "Run" : (value6.setup_reached ? "Surface" : "Setup"));
					arg2 = (value6.lob ? "Lob" : "Normal") + text;
				}
				bool flag2 = range_burrow_approach.ContainsKey(worm);
				bool flag3 = attack_backoff.Contains(worm);
				bool flag4 = committed_attack_runs.ContainsKey(worm);
				float dist;
				Player val = NearestPardner(((Component)worm).transform.position, out dist);
				float num = (((Object)(object)val != (Object)null) ? TargetHeightAboveGround(val, ((Component)val).transform.position) : 0f);
				float num2 = DesiredDiveLaunchDistance(num);
				Plugin.log.LogInfo((object)($"[worm] state={value} hp={value2}/{value3} pos={((Component)worm).transform.position} " + $"owner={((NetworkBehaviour)worm).IsOwner} move=({a.move_x:F0},{a.move_y:F0}) dive={a.dive} " + $"wantBurrow={flag} recovery={arg} plan={arg2} " + $"commitRun={flag4} rangeBurrow={flag2} backoff={flag3} " + $"targetRange={dist:F1} sandHeight={num:F1} launchRange={num2:F1}"));
			}
			catch (Exception ex)
			{
				Plugin.log.LogWarning((object)("[worm] debug failed: " + ex.Message));
			}
		}

		public static WormAction Current(WormMovement worm)
		{
			if (!actions.TryGetValue(worm, out var value))
			{
				return default(WormAction);
			}
			return value;
		}

		public static Vector3 MoveDir(WormMovement worm)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (move_controllers.TryGetValue(worm, out var value))
			{
				return value.output;
			}
			WormAction wormAction = Current(worm);
			Vector3 result = default(Vector3);
			((Vector3)(ref result))..ctor(wormAction.move_x, 0f, wormAction.move_y);
			if (!(((Vector3)(ref result)).sqrMagnitude > 1f))
			{
				return result;
			}
			return ((Vector3)(ref result)).normalized;
		}

		public static void DriveDiscreteActions(WormMovement worm)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_052b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0532: Unknown result type (might be due to invalid IL or missing references)
			//IL_0539: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0543: Unknown result type (might be due to invalid IL or missing references)
			//IL_054a: Unknown result type (might be due to invalid IL or missing references)
			//IL_054f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0554: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Unknown result type (might be due to invalid IL or missing references)
			//IL_055d: Unknown result type (might be due to invalid IL or missing references)
			//IL_056f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0571: Unknown result type (might be due to invalid IL or missing references)
			//IL_0951: Unknown result type (might be due to invalid IL or missing references)
			//IL_0622: Unknown result type (might be due to invalid IL or missing references)
			WormAction a = Current(worm);
			try
			{
				Traverse val = Traverse.Create((object)worm);
				WormMouth component = ((Component)worm).GetComponent<WormMouth>();
				bool flag = (Object)(object)component == (Object)null || (int)component.thingInMouthType.Value == 0;
				if (scripted_control.Contains(worm))
				{
					bool value;
					bool flag2 = desired_burrowed.TryGetValue(worm, out value) && value;
					string text = SafeState(worm);
					float value2;
					float num = (next_unburrow.TryGetValue(worm, out value2) ? value2 : 0f);
					if (Time.time >= num)
					{
						if (flag2 && text == "Surface" && flag)
						{
							val.Method("Burrow", Array.Empty<object>()).GetValue();
							next_unburrow[worm] = Time.time + 1f;
						}
						else if (!flag2 && text == "Burrowed")
						{
							val.Method("UnBurrow", Array.Empty<object>()).GetValue();
							next_unburrow[worm] = Time.time + 1f;
						}
					}
				}
				bool flag3 = SafeBool(val, "canDive", fallback: false);
				string text2 = SafeState(worm);
				if (a.dive && (!flag3 || text2 != "Surface"))
				{
					LogDiveGate(worm, (!flag3) ? "cooldown" : ("state:" + text2));
				}
				if (a.dive && flag3 && text2 == "Surface")
				{
					WormPlayer component2 = ((Component)worm).GetComponent<WormPlayer>();
					Rigidbody component3 = ((Component)worm).GetComponent<Rigidbody>();
					if ((Object)(object)component2 != (Object)null && (Object)(object)component2.wormCam != (Object)null && (Object)(object)component3 != (Object)null)
					{
						DiveIntent diveIntent = null;
						DiveIntent value3;
						bool flag4 = dive_intents.TryGetValue(worm, out value3);
						if (flag4 && (Object)(object)value3.target != (Object)null && IsAlive(value3.target) && Time.time - value3.created_at <= Mathf.Max(0.15f, Time.fixedDeltaTime * 3f))
						{
							diveIntent = value3;
						}
						Player val2 = ((diveIntent != null) ? diveIntent.target : (flag4 ? null : WormPerception.SelectTarget(worm, Pardners())));
						if ((Object)(object)val2 != (Object)null && IsAlive(val2))
						{
							bool flag5 = diveIntent?.lob ?? false;
							float num2 = (flag5 ? Mathf.Clamp(diveIntent.lob_apex_height_scale, MinimumLobApexHeightScale(worm), 2f) : 0f);
							Vector3 val3 = WormPerception.PerceivedPosition(worm, val2) - ((Component)worm).transform.position;
							Vector3 val4 = new Vector3(val3.x, 0f, val3.z);
							float magnitude = ((Vector3)(ref val4)).magnitude;
							float num3 = SafeFloat(val, "divePower", 15f);
							float num4 = SafeFloat(val, "diveUpwardsPower", 6f);
							Vector3 direction;
							bool flag6 = TryPlanarDirection(val3, out direction);
							DiveSolution solution;
							if (magnitude <= 5f && Mathf.Abs(val3.y) <= 3f && !flag5)
							{
								Vector3 dir3d = val3;
								if (((Vector3)(ref dir3d)).sqrMagnitude < 0.0001f)
								{
									dir3d = ((Component)component2.wormCam).transform.forward;
								}
								AimCam3D(component2, dir3d);
								Vector3 val5 = ((Component)component2.wormCam).transform.forward;
								if (((Vector3)(ref val5)).sqrMagnitude < 0.0001f)
								{
									val5 = ((Vector3)(ref dir3d)).normalized;
								}
								attack_plans.Remove(worm);
								dive_intents.Remove(worm);
								committed_attack_runs.Remove(worm);
								attack_run_retry_at.Remove(worm);
								range_burrow_retry_at.Remove(worm);
								attack_backoff.Remove(worm);
								attack_backoff_dir.Remove(worm);
								committed_lob_dives.Remove(worm);
								committed_dive_dir[worm] = ((Vector3)(ref val5)).normalized;
								committed_dive_target[worm] = val2;
								ResetMoveControllerDamping(worm);
								Plugin.log.LogInfo((object)$"[worm] point-blank dive range={magnitude:F1}");
								val.Method("Dive", new object[1] { num3 }).GetValue();
							}
							else if (!flag5 && (magnitude > 50f || !flag6))
							{
								LogDiveGate(worm, $"range:{magnitude:F1}");
							}
							else if (!SolveDiveForWorm(worm, val2, ((Component)worm).transform.position, component3.velocity, num3, num4, flag5, num2, out solution))
							{
								string obj = (flag5 ? "lob" : "normal");
								val4 = component3.velocity;
								LogDiveGate(worm, "solve type=" + obj + " " + $"speed:{((Vector3)(ref val4)).magnitude:F1}");
							}
							else
							{
								AimCam3D(component2, solution.aim_dir);
								Vector3 forward = ((Component)component2.wormCam).transform.forward;
								if (((Vector3)(ref forward)).sqrMagnitude > 0.0001f)
								{
									((Vector3)(ref forward)).Normalize();
									float num5 = num3 * (flag5 ? Mathf.Max(0.01f, solution.power_scale) : Mathf.Max(1f, solution.power_scale));
									Vector3 val6 = component3.velocity + solution.aim_dir * num5 + Vector3.up * num4;
									Vector3 velocity = component3.velocity;
									velocity.y = 0f;
									float num6 = (flag5 ? ((Vector3)(ref velocity)).magnitude : Vector3.Dot(velocity, direction));
									if (num6 < 6f)
									{
										LogDiveGate(worm, $"speed:{num6:F1}");
									}
									else
									{
										attack_plans.Remove(worm);
										dive_intents.Remove(worm);
										committed_attack_runs.Remove(worm);
										attack_run_retry_at.Remove(worm);
										range_burrow_retry_at.Remove(worm);
										attack_backoff.Remove(worm);
										attack_backoff_dir.Remove(worm);
										if (flag5)
										{
											committed_lob_dives.Add(worm);
										}
										else
										{
											committed_lob_dives.Remove(worm);
										}
										committed_dive_dir[worm] = ((Vector3)(ref val6)).normalized;
										committed_dive_target[worm] = val2;
										ResetMoveControllerDamping(worm);
										Plugin.log.LogInfo((object)("[worm] dive commit type=" + (flag5 ? "lob" : "normal") + " " + $"apex={(flag5 ? num2 : 0f):F2}x " + $"range={magnitude:F1} " + $"scale={solution.power_scale:F2} flight={solution.flight_time:F2}"));
										val.Method("Dive", new object[1] { num5 }).GetValue();
									}
								}
							}
						}
						else
						{
							LogDiveGate(worm, flag4 ? "intent" : "target");
						}
					}
					else
					{
						LogDiveGate(worm, "components");
					}
				}
				bool value4;
				bool flag7 = prev_burrow.TryGetValue(worm, out value4) && value4;
				if (a.burrow && !flag7)
				{
					if (SafeState(worm) == "Burrowed")
					{
						val.Method("UnBurrow", Array.Empty<object>()).GetValue();
					}
					else if (flag)
					{
						val.Method("Burrow", Array.Empty<object>()).GetValue();
					}
				}
				prev_burrow[worm] = a.burrow;
				WormAbilityManager component4 = ((Component)worm).GetComponent<WormAbilityManager>();
				if ((Object)(object)component4 != (Object)null && a.abilities != null && AiWormDifficultyRules.For((Component)(object)worm) == AiWormDifficulty.Snake)
				{
					ApplySnakeAbilityPolicy(worm, component4, a);
				}
				if ((Object)(object)component4 != (Object)null && a.abilities != null)
				{
					bool[] value5;
					bool[] array = (prev_abilities.TryGetValue(worm, out value5) ? value5 : new bool[0]);
					bool[] array2 = new bool[a.abilities.Length];
					for (int i = 0; i < a.abilities.Length; i++)
					{
						array2[i] = a.abilities[i];
					}
					prev_abilities[worm] = array2;
					for (int j = 0; j < a.abilities.Length; j++)
					{
						if (!a.abilities[j] || (j < array.Length && array[j]))
						{
							continue;
						}
						WormAbility val7 = AbilityInSlot(component4, j);
						if (IsQueuedLostSightAbility(worm, j) && ((Object)(object)val7 == (Object)null || !val7.canUseAbility || !CanUseLostSightAbility(worm, val7, SafeState(worm))))
						{
							RequeueLostSightAbility(worm, j);
							a.abilities[j] = false;
							array2[j] = false;
							continue;
						}
						bool flag8 = val7 is WormAbility_BileBomb || val7 is WormAbility_SandStorm;
						GameManager singleton = GameManager.Singleton;
						WormPlayer component5 = ((Component)worm).GetComponent<WormPlayer>();
						Camera activeCamera = (((Object)(object)singleton != (Object)null) ? singleton.activeCamera : null);
						if (flag8 && (Object)(object)singleton != (Object)null && (Object)(object)component5 != (Object)null && (Object)(object)component5.wormCam != (Object)null)
						{
							singleton.activeCamera = component5.wormCam;
						}
						if (val7 is WormAbility_BileBomb && AiWormDifficultyRules.For((Component)(object)worm) == AiWormDifficulty.Snake)
						{
							Player val8 = WormPerception.SelectTarget(worm, Pardners());
							if ((Object)(object)val8 != (Object)null && IsAlive(val8))
							{
								BileBombRedirect.Arm(WormPerception.PerceivedPosition(worm, val8));
							}
						}
						try
						{
							component4.AttemptToUseAbility(j + 1);
							string arg = (((Object)(object)val7 != (Object)null) ? ((object)val7).GetType().Name : "empty");
							Plugin.log.LogInfo((object)$"[worm] ability press slot={j + 1} type={arg}");
						}
						finally
						{
							if (flag8 && (Object)(object)singleton != (Object)null)
							{
								singleton.activeCamera = activeCamera;
							}
							ConsumeLostSightAbility(worm, j);
						}
					}
				}
				else
				{
					prev_abilities.Remove(worm);
				}
			}
			catch (Exception ex)
			{
				if (!logged_drive_error)
				{
					logged_drive_error = true;
					Plugin.log.LogWarning((object)("discrete-action reflection failed (logged once): " + ex.Message));
				}
			}
		}

		private static WormAction Scripted(WormMovement worm)
		{
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_0528: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0806: Unknown result type (might be due to invalid IL or missing references)
			//IL_080d: Unknown result type (might be due to invalid IL or missing references)
			//IL_080f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0819: Unknown result type (might be due to invalid IL or missing references)
			//IL_081e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0823: Unknown result type (might be due to invalid IL or missing references)
			//IL_074b: Unknown result type (might be due to invalid IL or missing references)
			//IL_074d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0757: Unknown result type (might be due to invalid IL or missing references)
			//IL_075c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0761: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_064b: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0658: Unknown result type (might be due to invalid IL or missing references)
			//IL_0666: Unknown result type (might be due to invalid IL or missing references)
			//IL_0884: Unknown result type (might be due to invalid IL or missing references)
			//IL_0889: Unknown result type (might be due to invalid IL or missing references)
			//IL_088b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0890: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eaa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a77: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a7b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a80: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a85: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aaf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eb7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ec5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0adf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ae1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0afa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e5b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e60: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e52: Unknown result type (might be due to invalid IL or missing references)
			//IL_0950: Unknown result type (might be due to invalid IL or missing references)
			//IL_0955: Unknown result type (might be due to invalid IL or missing references)
			//IL_0959: Unknown result type (might be due to invalid IL or missing references)
			//IL_0967: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_08dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_08eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e68: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e6c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e71: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e82: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e90: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c98: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c9d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c8f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b55: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b47: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b4c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b4e: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d5b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ca2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ca5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ca9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cbf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ccd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b57: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b67: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b75: Unknown result type (might be due to invalid IL or missing references)
			//IL_09fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e12: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e20: Unknown result type (might be due to invalid IL or missing references)
			//IL_0de8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0df6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d8e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d93: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d95: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d9a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a34: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a36: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a3d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a3f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a16: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a18: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bf7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f69: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c04: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c12: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f8a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f8f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f91: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f96: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f9a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fa8: Unknown result type (might be due to invalid IL or missing references)
			WormAction action = new WormAction
			{
				abilities = new bool[4]
			};
			Transform transform = ((Component)worm).transform;
			WormPlayer component = ((Component)worm).GetComponent<WormPlayer>();
			float num = (((Object)(object)component != (Object)null) ? component.wormHealth : 100f);
			float num2 = (((Object)(object)component != (Object)null) ? component.wormHealth_Max : 100f);
			string text = SafeState(worm);
			bool flag = num < num2;
			if (flag)
			{
				attack_plans.Remove(worm);
				attack_searches.Remove(worm);
				committed_attack_runs.Remove(worm);
				attack_run_retry_at.Remove(worm);
				range_burrow_approach.Remove(worm);
				range_burrow_retry_at.Remove(worm);
				attack_backoff.Remove(worm);
				attack_backoff_dir.Remove(worm);
				attack_pressure.Remove(worm);
				lost_sight_abilities.Remove(worm);
			}
			if (text == "Diving" && committed_dive_dir.TryGetValue(worm, out var value))
			{
				desired_burrowed[worm] = false;
				AimCam3D(component, value);
				Vector3 val = value;
				val.y = 0f;
				if (((Vector3)(ref val)).sqrMagnitude > 0.0001f)
				{
					((Vector3)(ref val)).Normalize();
					action.move_x = val.x;
					action.move_y = val.z;
				}
				return action;
			}
			committed_dive_dir.Remove(worm);
			if (flag)
			{
				desired_burrowed[worm] = true;
				if (!flee_dir.TryGetValue(worm, out var value2))
				{
					Vector2 insideUnitCircle = Random.insideUnitCircle;
					Vector2 normalized = ((Vector2)(ref insideUnitCircle)).normalized;
					((Vector3)(ref value2))..ctor(normalized.x, 0f, normalized.y);
					flee_dir[worm] = value2;
				}
				action.move_x = value2.x;
				action.move_y = value2.z;
				return action;
			}
			flee_dir.Remove(worm);
			if (navigation_states.TryGetValue(worm, out var value3) && value3.phase != RecoveryPhase.None)
			{
				committed_attack_runs.Remove(worm);
				attack_run_retry_at.Remove(worm);
				desired_burrowed[worm] = value3.phase != RecoveryPhase.Surface;
				action.move_x = value3.recovery_dir.x;
				action.move_y = value3.recovery_dir.z;
				return action;
			}
			AttackPlan plan = null;
			if (attack_plans.TryGetValue(worm, out var value4))
			{
				bool flag2 = Time.time >= value4.expires_at;
				if ((Object)(object)value4.target == (Object)null || !IsAlive(value4.target) || flag2)
				{
					attack_plans.Remove(worm);
				}
				else
				{
					plan = value4;
				}
			}
			DiveIntent diveIntent = null;
			if (committed_attack_runs.TryGetValue(worm, out var value5))
			{
				bool flag3 = Time.time - value5.created_at >= 3f;
				if ((Object)(object)value5.target == (Object)null || !IsAlive(value5.target) || flag3)
				{
					committed_attack_runs.Remove(worm);
					if (flag3)
					{
						attack_run_retry_at[worm] = Time.time + 0.25f;
					}
				}
				else
				{
					diveIntent = value5;
				}
			}
			Player val2 = ((diveIntent != null) ? diveIntent.target : ((plan == null) ? WormPerception.SelectTarget(worm, Pardners()) : plan.target));
			if ((Object)(object)val2 == (Object)null)
			{
				attack_searches.Remove(worm);
				range_burrow_approach.Remove(worm);
				range_burrow_retry_at.Remove(worm);
				attack_backoff.Remove(worm);
				attack_backoff_dir.Remove(worm);
				committed_attack_runs.Remove(worm);
				attack_run_retry_at.Remove(worm);
				attack_pressure.Remove(worm);
				lost_sight_abilities.Remove(worm);
				desired_burrowed[worm] = false;
				return action;
			}
			Vector3 position = transform.position;
			Vector3 val3 = PredictPos(worm, val2, position);
			navigation_goals[worm] = val3;
			Vector3 val4 = val3 - position;
			Vector3 val5 = default(Vector3);
			((Vector3)(ref val5))..ctor(val4.x, 0f, val4.z);
			float magnitude = ((Vector3)(ref val5)).magnitude;
			float num3 = TargetHeightAboveGround(val2, val3);
			float num4 = DesiredDiveLaunchDistance(num3);
			bool flag4 = num3 >= 1.5f;
			if (diveIntent != null)
			{
				range_burrow_approach.Remove(worm);
				attack_backoff.Remove(worm);
				attack_backoff_dir.Remove(worm);
				desired_burrowed[worm] = false;
				AimCam3D(component, val4);
				if (TryPlanarDirection(val5, out var direction))
				{
					action.move_x = direction.x;
					action.move_y = direction.z;
				}
				if (text != "Surface")
				{
					surfaced_time[worm] = Time.time;
				}
				float value6;
				bool flag5 = surfaced_time.TryGetValue(worm, out value6) && Time.time - value6 < 1f;
				action.dive = text == "Surface" && (diveIntent.lob || !flag5);
				if (action.dive)
				{
					SetDiveIntent(worm, val2);
				}
				return action;
			}
			QueueLostSightAbility(worm, val2, text, val4, ref action);
			if (magnitude < 45f)
			{
				range_burrow_retry_at.Remove(worm);
			}
			float value7;
			float num5 = (range_burrow_retry_at.TryGetValue(worm, out value7) ? value7 : 0f);
			if (plan == null && !range_burrow_approach.ContainsKey(worm) && Time.time >= num5 && magnitude >= 45f)
			{
				range_burrow_approach[worm] = new RangeApproachState
				{
					best_distance = magnitude,
					last_progress_at = Time.time
				};
				attack_backoff.Remove(worm);
				attack_backoff_dir.Remove(worm);
				attack_plans.Remove(worm);
				plan = null;
			}
			if (range_burrow_approach.TryGetValue(worm, out var value8))
			{
				if (magnitude <= value8.best_distance - 1f)
				{
					value8.best_distance = magnitude;
					value8.last_progress_at = Time.time;
				}
				if (NavigationPathMakingProgress(worm))
				{
					value8.last_progress_at = Time.time;
				}
				bool flag6 = Time.time - value8.last_progress_at >= 2f;
				if (magnitude > 28f && !flag6)
				{
					desired_burrowed[worm] = true;
					if (TryPlanarDirection(val5, out var direction2))
					{
						action.move_x = direction2.x;
						action.move_y = direction2.z;
					}
					return action;
				}
				range_burrow_approach.Remove(worm);
				if (flag6)
				{
					range_burrow_retry_at[worm] = Time.time + 0.75f;
				}
				desired_burrowed[worm] = false;
				if (text != "Surface")
				{
					if (text == "Burrowed" && !CanSurfaceHere(worm))
					{
						bool wants_burrow;
						Vector3 val6 = BeginSurfaceRecovery(worm, val5, out wants_burrow);
						desired_burrowed[worm] = wants_burrow;
						action.move_x = val6.x;
						action.move_y = val6.z;
					}
					else
					{
						navigation_holds.Add(worm);
						action.move_x = 0f;
						action.move_y = 0f;
					}
					return action;
				}
			}
			if (text == "Surface" && magnitude <= 5f && plan == null && AnalyzePath(position + Vector3.up * 1.5f, val3, val2) != PathResult.Blocked)
			{
				attack_plans.Remove(worm);
				attack_searches.Remove(worm);
				plan = null;
				attack_backoff.Remove(worm);
				attack_backoff_dir.Remove(worm);
				desired_burrowed[worm] = false;
				AimCam3D(component, val4);
				if (TryPlanarDirection(val5, out var direction3))
				{
					action.move_x = direction3.x;
					action.move_y = direction3.z;
				}
				action.dive = BeginCommittedAttackRun(worm, val2);
				if (action.dive)
				{
					SetDiveIntent(worm, val2);
				}
				return action;
			}
			AimCam3D(component, val4);
			PathResult pathResult = AnalyzePath(position + Vector3.up * 1.5f, val3, val2);
			if (text != "Surface")
			{
				surfaced_time[worm] = Time.time;
			}
			float value9;
			bool flag7 = surfaced_time.TryGetValue(worm, out value9) && Time.time - value9 < 1f;
			if (plan != null)
			{
				if (!plan.attack_run)
				{
					Vector3 preferred_dir = plan.setup_pos - position;
					preferred_dir.y = 0f;
					if (text != "Surface")
					{
						if (text == "Burrowed" && !CanSurfaceHere(worm))
						{
							bool wants_burrow2;
							Vector3 val7 = BeginSurfaceRecovery(worm, preferred_dir, out wants_burrow2);
							desired_burrowed[worm] = wants_burrow2;
							action.move_x = val7.x;
							action.move_y = val7.z;
						}
						else
						{
							desired_burrowed[worm] = false;
							navigation_holds.Add(worm);
							action.move_x = 0f;
							action.move_y = 0f;
						}
						return action;
					}
					if (!plan.setup_reached && ((Vector3)(ref preferred_dir)).sqrMagnitude > 0.16000001f)
					{
						desired_burrowed[worm] = false;
						Vector3 normalized2 = ((Vector3)(ref preferred_dir)).normalized;
						action.move_x = normalized2.x;
						action.move_y = normalized2.z;
						return action;
					}
					if (!plan.setup_reached)
					{
						plan.setup_reached = true;
						plan.expires_at = Time.time + 2f;
						ResetMoveControllerDamping(worm);
					}
					desired_burrowed[worm] = false;
					navigation_holds.Add(worm);
					action.move_x = 0f;
					action.move_y = 0f;
					if (text != "Surface")
					{
						return action;
					}
					navigation_holds.Remove(worm);
					if (!TryGroundClearing(worm, plan.launch_pos, out var ground_pos) || !TryGroundClearing(worm, plan.setup_pos, out var ground_pos2) || (!plan.lob && !IsAttackRunClear(worm, ground_pos2, ground_pos)))
					{
						attack_plans.Remove(worm);
						plan = null;
					}
					else
					{
						plan.launch_pos = ground_pos;
						plan.setup_pos = ground_pos2;
						plan.attack_run = true;
						plan.expires_at = Time.time + 3f;
						ResetMoveControllerDamping(worm);
					}
				}
				if (plan != null)
				{
					desired_burrowed[worm] = false;
					Vector3 val8 = position - plan.launch_pos;
					val8.y = 0f;
					bool flag8 = ((Vector3)(ref val8)).sqrMagnitude <= 4f;
					Vector3 val9 = plan.launch_pos - plan.setup_pos;
					val9.y = 0f;
					bool flag9 = false;
					if (((Vector3)(ref val9)).sqrMagnitude > 0.0001f)
					{
						((Vector3)(ref val9)).Normalize();
						float num6 = Vector3.Dot(val8, val9);
						Vector3 val10 = val8 - val9 * num6;
						flag9 = num6 >= 0f && num6 <= 5f && ((Vector3)(ref val10)).sqrMagnitude <= 4f;
					}
					if (!plan.launch_reached && (flag8 || flag9))
					{
						plan.launch_reached = true;
					}
					Vector3 val11 = (plan.launch_reached ? val5 : (plan.launch_pos - position));
					val11.y = 0f;
					action.move_x = val11.x;
					action.move_y = val11.z;
					float num7 = plan.launch_distance + 6f;
					bool flag10 = plan.lob || flag4 || pathResult == PathResult.Clear || pathResult == PathResult.Building;
					bool flag11 = plan.lob || plan.launch_reached;
					action.dive = flag11 && (plan.lob || (magnitude <= num7 && flag10 && !flag7));
					if (action.dive)
					{
						if (TryPlanarDirection(val5, out var direction4))
						{
							action.move_x = direction4.x;
							action.move_y = direction4.z;
						}
						if (BeginCommittedAttackRun(worm, val2, plan.lob, plan.lob_apex_height_scale))
						{
							SetDiveIntent(worm, val2);
						}
						else
						{
							action.dive = false;
						}
					}
					return action;
				}
			}
			if (pathResult == PathResult.Blocked)
			{
				action.dive = false;
				if (text != "Surface")
				{
					if (text == "Burrowed" && !CanSurfaceHere(worm))
					{
						Vector3 preferred_dir2 = ((((Vector3)(ref val5)).sqrMagnitude > 0.01f) ? (-((Vector3)(ref val5)).normalized) : Vector3.forward);
						bool wants_burrow3;
						Vector3 val12 = BeginSurfaceRecovery(worm, preferred_dir2, out wants_burrow3);
						desired_burrowed[worm] = wants_burrow3;
						action.move_x = val12.x;
						action.move_y = val12.z;
					}
					else
					{
						desired_burrowed[worm] = false;
						navigation_holds.Add(worm);
						action.move_x = 0f;
						action.move_y = 0f;
					}
					return action;
				}
				AttackSearchState attackSearch = GetAttackSearch(worm, val2);
				float value10;
				float num8 = (attack_spot_retry.TryGetValue(worm, out value10) ? value10 : 0f);
				bool num9 = Time.time >= num8;
				if (num9)
				{
					attack_spot_retry[worm] = Time.time + 0.2f;
				}
				if (num9 && TryCreateAttackPlan(worm, val2, position, attackSearch.lob, attackSearch.lob_apex_height_scale, out plan))
				{
					attack_searches.Remove(worm);
					desired_burrowed[worm] = false;
					Vector3 val13 = plan.setup_pos - position;
					action.move_x = val13.x;
					action.move_y = val13.z;
				}
				else if (Time.time - attackSearch.started_at >= 1f)
				{
					attackSearch.started_at = Time.time;
					desired_burrowed[worm] = true;
					action.move_x = val5.x;
					action.move_y = val5.z;
				}
				else
				{
					desired_burrowed[worm] = false;
					action.move_x = val5.x;
					action.move_y = val5.z;
				}
				return action;
			}
			if (text == "Burrowed" && !CanSurfaceHere(worm))
			{
				Vector3 preferred_dir3 = ((((Vector3)(ref val5)).sqrMagnitude > 0.01f) ? (-((Vector3)(ref val5)).normalized) : Vector3.forward);
				bool wants_burrow4;
				Vector3 val14 = BeginSurfaceRecovery(worm, preferred_dir3, out wants_burrow4);
				desired_burrowed[worm] = wants_burrow4;
				action.move_x = val14.x;
				action.move_y = val14.z;
				return action;
			}
			desired_burrowed[worm] = false;
			if (TryPlanarDirection(val5, out var direction5))
			{
				action.move_x = direction5.x;
				action.move_y = direction5.z;
			}
			bool flag12 = pathResult == PathResult.Clear || pathResult == PathResult.Building;
			bool num10 = magnitude >= num4 - 4f && magnitude <= num4 + 6f && flag12 && !flag7;
			action.dive = false;
			if (num10)
			{
				AttackSearchState attackSearch2 = GetAttackSearch(worm, val2);
				if (attackSearch2.lob)
				{
					float value11;
					float num11 = (attack_spot_retry.TryGetValue(worm, out value11) ? value11 : 0f);
					if (Time.time >= num11)
					{
						attack_spot_retry[worm] = Time.time + 0.2f;
						if (TryCreateAttackPlan(worm, val2, position, lob: true, attackSearch2.lob_apex_height_scale, out plan))
						{
							attack_searches.Remove(worm);
							Vector3 val15 = plan.setup_pos - position;
							action.move_x = val15.x;
							action.move_y = val15.z;
						}
					}
					return action;
				}
				action.dive = BeginCommittedAttackRun(worm, val2);
				if (action.dive)
				{
					attack_searches.Remove(worm);
					SetDiveIntent(worm, val2);
				}
			}
			return action;
		}

		private static bool TryApplyAttackPressure(WormMovement worm, bool scripted_action, ref WormAction a)
		{
			//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_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			if (attack_plans.ContainsKey(worm) || attack_searches.ContainsKey(worm) || committed_attack_runs.ContainsKey(worm))
			{
				attack_pressure.Remove(worm);
				return false;
			}
			Player val = PressureTarget(worm, scripted_action);
			string text = SafeState(worm);
			WormPlayer component = ((Component)worm).GetComponent<WormPlayer>();
			bool flag = (Object)(object)component != (Object)null && component.wormHealth < component.wormHealth_Max;
			bool flag2 = IsAttackPressureForcing(worm);
			NavigationState value;
			bool flag3 = navigation_states.TryGetValue(worm, out value) && value.phase != RecoveryPhase.None;
			if ((Object)(object)val == (Object)null || !IsAlive(val) || flag || (flag3 && !flag2) || text == "Diving")
			{
				ClearAttackPressure(worm);
				return false;
			}
			Vector3 val2 = PredictPos(worm, val, ((Component)worm).transform.position) - ((Component)worm).transform.position;
			Vector3 value2 = default(Vector3);
			((Vector3)(ref value2))..ctor(val2.x, 0f, val2.z);
			float magnitude = ((Vector3)(ref value2)).magnitude;
			if (!attack_pressure.TryGetValue(worm, out var value3) || (Object)(object)value3.target != (Object)(object)val)
			{
				value3 = new AttackPressureState
				{
					target = val
				};
				attack_pressure[worm] = value3;
			}
			if (magnitude > 36f)
			{
				ClearAttackPressure(worm);
				return false;
			}
			if (value3.near_since < 0f)
			{
				if (magnitude <= 30f)
				{
					value3.near_since = Time.time;
				}
				return false;
			}
			if (value3.forcing_since < 0f && Time.time - value3.near_since >= 10f)
			{
				value3.forcing_since = Time.time;
				Plugin.log.LogInfo((object)$"[worm] pressure dive engaged range={magnitude:F1}");
			}
			if (value3.forcing_since < 0f)
			{
				return false;
			}
			attack_plans.Remove(worm);
			attack_spot_retry.Remove(worm);
			attack_searches.Remove(worm);
			committed_attack_runs.Remove(worm);
			attack_run_retry_at.Remove(worm);
			range_burrow_approach.Remove(worm);
			range_burrow_retry_at.Remove(worm);
			attack_backoff.Remove(worm);
			attack_backoff_dir.Remove(worm);
			lost_sight_abilities.Remove(worm);
			navigation_holds.Remove(worm);
			dive_intents.Remove(worm);
			if (value != null)
			{
				value.phase = RecoveryPhase.None;
				value.has_surface_target = false;
			}
			desired_burrowed[worm] = false;
			a.burrow = false;
			if (a.abilities == null || a.abilities.Length != 4)
			{
				a.abilities = new bool[4];
			}
			else
			{
				for (int i = 0; i < a.abilities.Length; i++)
				{
					a.abilities[i] = false;
				}
			}
			AimCam3D(component, val2);
			if (TryPlanarDirection(value2, out var direction))
			{
				a.move_x = direction.x;
				a.move_y = direction.z;
			}
			if (text != "Surface")
			{
				surfaced_time[worm] = Time.time;
			}
			float value4;
			bool flag4 = surfaced_time.TryGetValue(worm, out value4) && Time.time - value4 < 1f;
			bool num = text == "Surface" && !flag4 && Time.time - value3.forcing_since >= 0.45f;
			a.dive = false;
			if (num)
			{
				attack_pressure.Remove(worm);
				GetAttackSearch(worm, val);
				a = Scripted(worm);
			}
			return true;
		}

		private static Player PressureTarget(WormMovement worm, bool scripted_action)
		{
			if (scripted_action && committed_attack_runs.TryGetValue(worm, out var value) && (Object)(object)value.target != (Object)null && IsAlive(value.target))
			{
				return value.target;
			}
			if (scripted_action && attack_plans.TryGetValue(worm, out var value2) && (Object)(object)value2.target != (Object)null && IsAlive(value2.target))
			{
				return value2.target;
			}
			return WormPerception.SelectTarget(worm, Pardners());
		}

		private static void ClearAttackPressure(WormMovement worm)
		{
			if (attack_pressure.TryGetValue(worm, out var value) && value.forcing_since >= 0f)
			{
				committed_attack_runs.Remove(worm);
				dive_intents.Remove(worm);
			}
			attack_pressure.Remove(worm);
		}

		private static AttackSearchState GetAttackSearch(WormMovement worm, Player target)
		{
			if (!attack_searches.TryGetValue(worm, out var value) || (Object)(object)value.target != (Object)(object)target || Time.time >= value.expires_at)
			{
				value = new AttackSearchState
				{
					target = target,
					started_at = Time.time,
					expires_at = Time.time + 4f,
					lob = true,
					lob_apex_height_scale = ((AiWormDifficultyRules.For((Component)(object)worm) == AiWormDifficulty.Bull) ? 1f : Random.Range(1.25f, 2f))
				};
				attack_searches[worm] = value;
				Plugin.log.LogInfo((object)("[worm] attack selected type=lob " + $"apex={value.lob_apex_height_scale:F2}x"));
			}
			return value;
		}

		private static bool TryCreateAttackPlan(WormMovement worm, Player target, Vector3 worm_pos, bool lob, float lob_apex_height_scale, out AttackPlan plan)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			plan = null;
			if (!TryFindAttackSpot(worm, target, worm_pos, lob, lob_apex_height_scale, out var launch_pos, out var setup_pos, out var launch_distance))
			{
				return false;
			}
			plan = new AttackPlan
			{
				target = target,
				launch_pos = launch_pos,
				setup_pos = setup_pos,
				attack_run = false,
				setup_reached = false,
				launch_reached = false,
				lob = lob,
				lob_apex_height_scale = lob_apex_height_scale,
				launch_distance = launch_distance,
				expires_at = Time.time + 4f + Vector3.Distance(worm_pos, setup_pos) / (13f * DifficultyMultiplier(worm)) * 1.5f
			};
			attack_plans[worm] = plan;
			return true;
		}

		private static bool TryFindAttackSpot(WormMovement worm, Player target, Vector3 wormPos, bool lob, float lob_apex_height_scale, out Vector3 launch_pos, out Vector3 setup_pos, out float launch_distance)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_006f: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: 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)
			launch_pos = Vector3.zero;
			setup_pos = Vector3.zero;
			launch_distance = 0f;
			Vector3 val = WormPerception.PerceivedPosition(worm, target);
			float num = (lob ? DesiredLobLaunchDistance(worm, target, val, lob_apex_height_scale) : DesiredDiveLaunchDistance(TargetHeightAboveGround(target, val)));
			float num2 = (lob ? 4f : 3f);
			float num3 = (lob ? 50f : 26f);
			int num4 = (lob ? 5 : 3);
			Vector3 val2 = wormPos - val;
			val2.y = 0f;
			float num5 = ((((Vector3)(ref val2)).sqrMagnitude > 0.0001f) ? Mathf.Atan2(val2.z, val2.x) : 0f);
			Vector3 val3 = default(Vector3);
			for (int i = 0; i < num4; i++)
			{
				float num6 = ((i == 0) ? 0f : (((i % 2 == 1) ? 1f : (-1f)) * (float)((i + 1) / 2) * num2));
				float num7 = Mathf.Clamp(num + num6, 5f, num3);
				bool flag = false;
				for (int j = 0; j < i; j++)
				{
					float num8 = ((j == 0) ? 0f : (((j % 2 == 1) ? 1f : (-1f)) * (float)((j + 1) / 2) * num2));
					float num9 = Mathf.Clamp(num + num8, 5f, num3);
					if (Mathf.Approximately(num7, num9))
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					continue;
				}
				for (int k = 0; k < 8; k++)
				{
					int num10 = ((k != 0) ? ((k + 1) / 2 * ((k % 2 == 1) ? 1 : (-1))) : 0);
					float num11 = num5 + (float)num10 * (MathF.PI / 4f);
					((Vector3)(ref val3))..ctor(Mathf.Cos(num11), 0f, Mathf.Sin(num11));
					Vector3 val4 = val + val3 * num7;
					Vector3 candidate = val4 + val3 * 10f;
					if (TryGroundClearing(worm, val4, out var ground_pos) && TryGroundClearing(worm, candidate, out var ground_pos2) && (lob || IsAttackRunClear(worm, ground_pos2, ground_pos)) && CanPlanDiveFrom(worm, target, ground_pos, lob))
					{
						launch_pos = ground_pos;
						setup_pos = ground_pos2;
						launch_distance = num7;
						return true;
					}
				}
			}
			return false;
		}

		private static void KeepWormCamOff(WormMovement worm)
		{
			try
			{
				WormPlayer component = ((Component)worm).GetComponent<WormPlayer>();
				if ((Object)(object)component != (Object)null && (Object)(object)component.wormCam != (Object)null && ((Behaviour)component.wormCam).enabled)
				{
					((Behaviour)component.wormCam).enabled = false;
				}
				if (!worm_listener.TryGetValue(worm, out var value) || (Object)(object)value == (Object)null)
				{
					value = (((Object)(object)component != (Object)null && (Object)(object)component.wormCam != (Object)null) ? ((Component)component.wormCam).GetComponent<AudioListener>() : null);
					if ((Object)(object)value == (Object)null)
					{
						value = ((Component)worm).GetComponentInChildren<AudioListener>(true);
					}
					if ((Object)(object)value != (Object)null)
					{
						worm_listener[worm] = value;
					}
				}
				if ((Object)(object)value != (Object)null && ((Behaviour)value).enabled)
				{
					((Behaviour)value).enabled = false;
				}
			}
			catch
			{
			}
		}

		private static void UpdatePardnerVel()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_0065: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			float time = Time.time;
			float num = time - last_vel_time;
			if (num < 0.05f)
			{
				return;
			}
			last_vel_time = time;
			Player[] array = Pardners();
			foreach (Player val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Vector3 position = ((Component)val).transform.position;
					if (pardner_pos.TryGetValue(val, out var value) && num > 0f)
					{
						pardner_vel[val] = (position - value) / num;
					}
					pardner_pos[val] = position;
				}
			}
		}

		private static void TrackDiveEnd(WormMovement worm)
		{
			string text = SafeState(worm);
			if (prev_dive_state.TryGetValue(worm, out var value) && value != "Diving" && text == "Diving")
			{
				ClearAttackPressure(worm);
			}
			if (prev_dive_state.TryGetValue(worm, out var value2) && value2 == "Diving" && text != "Diving")
			{
				WormPerception.OnDiveEnded(worm);
			}
			prev_dive_state[worm] = text;
		}

		private static Vector3 PredictPos(WormMovement worm, Player target, Vector3 wormPos)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = WormPerception.PerceivedPosition(worm, target);
			Vector3 val2 = WormPerception.PerceivedVelocity(worm, target);
			float num = Mathf.Clamp(Vector3.Distance(wormPos, val) / (60f * DifficultyMultiplier(worm)), 0f, 1f);
			return val + val2 * num;
		}

		private static Vector3 TargetVelocity(Player target)
		{
			//IL_0016: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 value;
			return Vector3.ClampMagnitude(pardner_vel.TryGetValue(target, out value) ? value : Vector3.zero, 8f);
		}

		private static void AimCam3D(WormPlayer wp, Vector3 dir3d)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)wp != (Object)null && (Object)(object)wp.wormCam != (Object)null && ((Vector3)(ref dir3d)).sqrMagnitude > 0.01f)
				{
					((Component)wp.wormCam).transform.rotation = Quaternion.LookRotation(((Vector3)(ref dir3d)).normalized, Vector3.up);
					WormCamLook componentInChildren = ((Component)wp).GetComponentInChildren<WormCamLook>(true);
					if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.wormHeadArt != (Object)null)
					{
						componentInChildren.wormHeadArt.rotation = ((Component)wp.wormCam).transform.rotation;
					}
				}
			}
			catch
			{
			}
		}

		private static void MaintainCommittedDiveAim(WormMovement worm)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (SafeState(worm) == "Diving" && committed_dive_dir.TryGetValue(worm, out var value))
			{
				AimCam3D(((Component)worm).GetComponent<WormPlayer>(), value);
			}
			else if (SafeState(worm) != "Diving")
			{
				committed_dive_dir.Remove(worm);
			}
		}

		private static void ApplyDiveHoming(WormMovement worm)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: 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_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			if (SafeState(worm) != "Diving")
			{
				committed_dive_target.Remove(worm);
				committed_lob_dives.Remove(worm);
				dive_homing_initial_distance.Remove(worm);
			}
			else
			{
				if (!committed_dive_target.TryGetValue(worm, out var value) || (Object)(object)value == (Object)null || !IsAlive(value))
				{
					return;
				}
				Rigidbody component = ((Component)worm).GetComponent<Rigidbody>();
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				Vector3 velocity = component.velocity;
				float magnitude = ((Vector3)(ref velocity)).magnitude;
				if (magnitude < 0.01f)
				{
					return;
				}
				if (committed_lob_dives.Contains(worm) && velocity.y >= 0f)
				{
					dive_homing_initial_distance.Remove(worm);
					return;
				}
				Vector3 val = ((Component)value).transform.position + Vector3.up * 1f - ((Component)worm).transform.position;
				if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
				{
					return;
				}
				float magnitude2 = ((Vector3)(ref val)).magnitude;
				if (!dive_homing_initial_distance.TryGetValue(worm, out var value2))
				{
					value2 = magnitude2;
					dive_homing_initial_distance[worm] = value2;
				}
				if (!(Vector3.Dot(velocity / magnitude, val / magnitude2) < 0.7071068f))
				{
					float num = Mathf.Clamp01(magnitude2 / Mathf.Max(0.01f, value2));
					Vector3 val2 = ((Vector3)(ref val)).normalized * magnitude;
					float num2 = 142.5f * num * DifficultyMultiplier(worm) * (MathF.PI / 180f) * Time.fixedDeltaTime;
					Vector3 val3 = Vector3.RotateTowards(velocity, val2, num2, 0f);
					if (val3.y > velocity.y)
					{
						val3.y = velocity.y;
					}
					component.velocity = val3;
				}
			}
		}

		private static PathResult AnalyzePath(Vector3 from, Vector3 to, Player target)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = to - from;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 0.5f)
			{
				return PathResult.Clear;
			}
			val /= magnitude;
			RaycastHit[] array = Physics.RaycastAll(from, val, magnitude);
			Array.Sort(array, (RaycastHit x, RaycastHit y) => ((RaycastHit)(ref x)).distance.CompareTo(((RaycastHit)(ref y)).distance));
			RaycastHit[] array2 = array;
			for (int num = 0; num < array2.Length; num++)
			{
				RaycastHit val2 = array2[num];
				Collider collider = ((RaycastHit)(ref val2)).collider;
				if (!((Object)(object)collider == (Object)null) && ((Component)collider).gameObject.layer != 7 && !((Object)(object)((Component)collider).GetComponentInParent<WormPlayer>() != (Object)null) && !((Object)(object)((Component)collider).GetComponentInParent<Player>() != (Object)null))
				{
					if ((Object)(object)((Component)collider).GetComponentInParent<CollapsibleBuilding>() != (Object)null)
					{
						return PathResult.Building;
					}
					return PathResult.Blocked;
				}
			}
			return PathResult.Clear;
		}

		private static bool TryGroundHit(Vector3 pos, out RaycastHit hit)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			return Physics.Raycast(new Vector3(pos.x, 100f, pos.z), Vector3.down, ref hit, 400f, ground_only_mask, (QueryTriggerInteraction)1);
		}

		private static float TargetHeightAboveGround(Player target, Vector3 target_pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (TryGroundHit(target_pos, out var hit))
			{
				float num = 0f;
				PlayerMovement val = (((Object)(object)target != (Object)null) ? ((Component)target).GetComponent<PlayerMovement>() : null);
				if ((Object)(object)val != (Object)null && (Object)(object)val.currentCollider != (Object)null)
				{
					float y = ((Component)target).transform.position.y;
					Bounds bounds = ((Collider)val.currentCollider).bounds;
					num = Mathf.Max(0f, y - ((Bounds)(ref bounds)).min.y);
				}
				return Mathf.Clamp(target_pos.y - num - ((RaycastHit)(ref hit)).point.y, 0f, 8f);
			}
			return 0f;
		}

		private static float DesiredDiveLaunchDistance(float target_height)
		{
			return Mathf.Clamp(8f + target_height * 1.5f, 5f, 26f);
		}

		private static float DesiredLobLaunchDistance(WormMovement worm, Player target, Vector3 target_pos, float lob_apex_height_scale)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			float start_y = ((Component)worm).transform.position.y + 0.2f;
			if (TryGroundHit(target_pos, out var hit))
			{
				start_y = ((RaycastHit)(ref hit)).point.y + 0.2f;
			}
			Vector3 val = Vector3.ClampMagnitude(WormPerception.PerceivedVelocity(worm, target), 8f);
			if (!TryLobFlightTime(worm, target, target_pos, val, start_y, lob_apex_height_scale, out var flight_time, out var launch_velocity_y, out var _))
			{
				return 50f;
			}
			Traverse t = Traverse.Create((object)worm);
			float num = SafeFloat(t, "divePower", 15f);
			float num2 = SafeFloat(t, "diveUpwardsPower", 6f);
			float num3 = launch_velocity_y - num2;
			float num4 = Mathf.Max(num * 1.1f, Mathf.Abs(num3));
			float num5 = Mathf.Sqrt(Mathf.Max(0f, num4 * num4 - num3 * num3));
			Vector3 direction;
			float num6 = (TryPlanarDirection(target_pos - ((Component)worm).transform.position, out direction) ? Vector3.Dot(val, direction) : 0f);
			return Mathf.Clamp((13f * DifficultyMultiplier(worm) + num5 - num6) * flight_time, 5f, 50f);
		}

		private static void LobTargetDimensions(Player target, out float feet_offset, out float body_height)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			feet_offset = 1f;
			body_height = 2f;
			PlayerMovement val = (((Object)(object)target != (Object)null) ? ((Component)target).GetComponent<PlayerMovement>() : null);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.currentCollider == (Object)null))
			{
				Bounds bounds = ((Collider)val.currentCollider).bounds;
				if (!(((Bounds)(ref bounds)).size.y <= 0.1f))
				{
					feet_offset = Mathf.Max(0f, ((Component)target).transform.position.y - ((Bounds)(ref bounds)).min.y);
					body_height = ((Bounds)(ref bounds)).size.y;
				}
			}
		}

		private static bool TryLobFlightTime(WormMovement worm, Player target, Vector3 target_pos, Vector3 target_velocity, float start_y, float lob_apex_height_scale, out float flight_time, out float launch_velocity_y, out float apex_y)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			flight_time = 0f;
			launch_velocity_y = 0f;
			LobTargetDimensions(target, out var feet_offset, out var body_height);
			float num = Mathf.Clamp(lob_apex_height_scale, MinimumLobApexHeightScale(worm), 2f);
			apex_y = target_pos.y - feet_offset + body_height * num;
			float num2 = 0f - Physics.gravity.y;
			float num3 = apex_y - start_y;
			if (num2 <= 0.0001f || num3 <= 0f)
			{
				return false;
			}
			launch_velocity_y = Mathf.Sqrt(2f * num2 * num3);
			float num4 = target_pos.y + 1f - start_y;
			float num5 = launch_velocity_y - target_velocity.y;
			float num6 = num5 * num5 - 2f * num2 * num4;
			if (num6 < 0f)
			{
				return false;
			}
			flight_time = (num5 + Mathf.Sqrt(num6)) / num2;
			float num7 = launch_velocity_y / num2;
			if (!float.IsNaN(flight_time) && !float.IsInfinity(flight_time))
			{
				return flight_time > num7;
			}
			return false;
		}

		private static bool CanPlanDiveFrom(WormMovement worm, Player target, Vector3 launch_pos, bool lob)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0083: 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 (lob)
			{
				return true;
			}
			if (!TryPlanarDirection(WormPerception.PerceivedPosition(worm, target) - launch_pos, out var direction))
			{
				return false;
			}
			Vector3 current_velocity = direction * 13f * DifficultyMultiplier(worm);
			Traverse t = Traverse.Create((object)worm);
			float num = SafeFloat(t, "divePower", 15f);
			float dive_up_power = SafeFloat(t, "diveUpwardsPower", 6f);
			Vector3 start = launch_pos + Vector3.up * 0.2f;
			if (TrySolveDiveTrajectory(worm, target, start, current_velocity, num, dive_up_power, out var solution))
			{
				return AnalyzeDiveTrajectory(worm, start, current_velocity, num * solution.power_scale, dive_up_power, solution) != PathResult.Blocked;
			}
			return false;
		}

		private static bool TrySolveDiveTrajectory(WormMovement worm, Player target, Vector3 start, Vector3 current_velocity, float dive_power, float dive_up_power, out DiveSolution solution)
		{
			//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_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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			solution = default(DiveSolution);
			Vector3 val = WormPerception.PerceivedVelocity(worm, target);
			for (float num = 0.2f; num <= 1.6f; num += 0.02f)
			{
				Vector3 val2 = WormPerception.PerceivedPosition(worm, target) + val * num + Vector3.up * 1f;
				Vector3 val3 = (val2 - start) / num - current_velocity - Vector3.up * dive_up_power - Physics.gravity * (0.5f * num);
				float magnitude = ((Vector3)(ref val3)).magnitude;
				if (magnitude < 0.001f)
				{
					continue;
				}
				float num2 = magnitude / Mathf.Max(0.01f, dive_power);
				if (!(num2 < 1f) && !(num2 > 1.75f))
				{
					Vector3 val4 = val3 / magnitude;
					if (TryPlanarDirection(val2 - start, out var direction) && TryPlanarDirection(val4, out var direction2) && !(Vector3.Dot(direction, direction2) < 0.45f))
					{
						solution = new DiveSolution
						{
							aim_dir = val4,
							target_pos = val2,
							flight_time = num,
							miss_distance = 0f,
							power_scale = num2
						};
						return true;
					}
				}
			}
			return false;
		}

		private static bool TrySolveLob(WormMovement worm, Player target, Vector3 start, Vector3 current_velocity, float dive_power, float dive_up_power, float lob_apex_height_scale, out DiveSolution solution)
		{
			//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_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			solution = default(DiveSolution);
			Vector3 val = WormPerception.PerceivedPosition(worm, target);
			Vector3 val2 = Vector3.ClampMagnitude(WormPerception.PerceivedVelocity(worm, target), 8f);
			if (!TryLobFlightTime(worm, target, val, val2, start.y, lob_apex_height_scale, out var flight_time, out var _, out var _))
			{
				return false;
			}
			val += val2 * flight_time + Vector3.up * 1f;
			Vector3 val3 = (val - start) / flight_time - current_velocity - Vector3.up * dive_up_power - Physics.gravity * (0.5f * flight_time);
			float magnitude = ((Vector3)(ref val3)).magnitude;
			if (magnitude < 0.001f)
			{
				return false;
			}
			float power_scale = magnitude / Mathf.Max(0.01f, dive_power);
			Vector3 aim_dir = val3 / magnitude;
			solution = new DiveSolution
			{
				aim_dir = aim_dir,
				target_pos = val,
				flight_time = flight_time,
				miss_distance = 0f,
				power_scale = power_scale
			};
			return true;
		}

		private static bool SolveDiveForWorm(WormMovement worm, Player target, Vector3 start, Vector3 current_velocity, float dive_power, float dive_up_power, bool lob, float lob_apex_height_scale, out DiveSolution solution)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			if (lob)
			{
				return TrySolveLob(worm, target, start, current_velocity, dive_power, dive_up_power, lob_apex_height_scale, out solution);
			}
			return TrySolveDiveTrajectory(worm, target, start, current_velocity, dive_power, dive_up_power, out solution);
		}

		private static PathResult AnalyzeDiveTrajectory(WormMovement worm, Vector3 start, Vector3 current_velocity, float dive_power, float dive_up_power, DiveSolution solution)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: 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_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = current_velocity + solution.aim_dir * dive_power + Vector3.up * dive_up_power;
			Vector3 val2 = start;
			float num = 0f;
			PathResult result = PathResult.Clear;
			for (int i = 1; i <= 12; i++)
			{
				float num2 = solution.flight_time * (float)i / 12f;
				Vector3 val3 = start + val * num2 + Physics.gravity * (0.5f * num2 * num2);
				float num3 = (num + num2) * 0.5f;
				if (!IsDivePointAboveGround(start + val * num3 + Physics.gravity * (0.5f * num3 * num3), num3) || !IsDivePointAboveGround(val3, num2))
				{
					return PathResult.Blocked;
				}
				Vector3 val4 = val3 - val2;
				float num4 = ((Vector3)(ref val4)).magnitude;
				Vector3 val5 = ((num4 > 0.0001f) ? (val4 / num4) : Vector3.zero);
				Vector3 val6 = solution.target_pos - val2;
				float num5 = Vector3.Dot(val6, val5);
				float num6 = ((Vector3)(ref val6)).sqrMagnitude - num5 * num5;
				float num7 = 1.5625f;
				bool flag = num5 >= 0f && num5 <= num4 && num6 <= num7;
				if (flag)
				{
					float num8 = Mathf.Sqrt(Mathf.Max(0f, num7 - num6));
					float num9 = Mathf.Max(0f, num5 - num8);
					if (num9 <= 0.05f)
					{
						break;
					}
					val4 = val5 * num9;
					num4 = num9;
				}
				if (num4 > 0.05f)
				{
					int num10 = Physics.SphereCastNonAlloc(val2, 1.05f, val4 / num4, dive_lane_hits, num4, dive_lane_mask, (QueryTriggerInteraction)1);
					for (int j = 0; j < num10; j++)
					{
						Collider collider = ((RaycastHit)(ref dive_lane_hits[j])).collider;
						if ((Object)(object)collider == (Object)null || ((Object)(object)GameManager.Singleton != (Object)null && (Object)(object)collider == (Object)(object)GameManager.Singleton.duplicateWormOnlyTerrain_Collider))
						{
							continue;
						}
						WormMovement componentInParent = ((Component)collider).GetComponentInParent<WormMovement>();
						if (!((Object)(object)componentInParent == (Object)(object)worm) && !((Object)(object)((Component)collider).GetComponentInParent<Player>() != (Object)null))
						{
							if ((Object)(object)componentInParent != (Object)null || (Object)(object)((Component)collider).GetComponentInParent<WormPlayer>() != (Object)null)
							{
								return PathResult.Blocked;
							}
							if (!((Object)(object)((Component)collider).GetComponentInParent<CollapsibleBuilding>() != (Object)null))
							{
								return PathResult.Blocked;
							}
							result = PathResult.Building;
						}
					}
				}
				if (flag)
				{
					break;
				}
				val2 = val3;
				num = num2;
			}
			return result;
		}

		private static bool IsDivePointAboveGround(Vector3 point, float flight_time)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!(flight_time <= 0.2f))
			{
				if (TryGroundHit(point, out var hit))
				{
					return point.y >= ((RaycastHit)(ref hit)).point.y + 0.3f;
				}
				return false;
			}
			return true;
		}

		private static void ApplyNavigation(WormMovement worm, bool scripted_action, ref WormAction a)
		{
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0417: Unknown result type (might be due to invalid IL or missing references)
			if (!navigation_states.TryGetValue(worm, out var value))
			{
				value = new NavigationState();
				navigation_states[worm] = value;
			}
			float num = UpdateNavigationObservation(worm, value);
			string text = SafeState(worm);
			WormPlayer component = ((Component)worm).GetComponent<WormPlayer>();
			bool flag = (Object)(object)component != (Object)null && component.wormHealth < component.wormHealth_Max;
			bool flag2 = text == "Surface" || text == "Burrowed";
			if (!flag2)
			{
				if (text == "Diving")
				{
					value.phase = RecoveryPhase.None;
					value.has_surface_target = false;
				}
				value.surface_unstick_until = 0f;
				ClearNavigationPath(value);
				ResetAvoidance(value);
				StoreNavigationCommand(value, a);
				return;
			}
			if (value.phase != RecoveryPhase.None)
			{
				ClearNavigationPath(value);
				if (scripted_action)
				{
					if (flag && value.phase == RecoveryPhase.Surface)
					{
						value.phase = RecoveryPhase.Burrow;
						value.phase_started = Time.time;
					}
					DriveRecovery(worm, value, text, num, ref a);
					StoreNavigationCommand(value, a);
					return;
				}
				value.phase = RecoveryPhase.None;
				value.has_surface_target = false;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(a.move_x, 0f, a.move_y);
			float num2 = Mathf.Clamp01(((Vector3)(ref val)).magnitude);
			Vector3 val2 = ((num2 > 0.0001f) ? ((Vector3)(ref val)).normalized : Vector3.zero);
			if (((Vector3)(ref val2)).sqrMagnitude > 0f && ((Vector3)(ref value.last_requested_dir)).sqrMagnitude > 0f && Vector3.Dot(val2, value.last_requested_dir) < 0.707f)
			{
				value.direction_grace_until = Time.time + 0.2f;
				value.low_motion_time = 0f;
				value.blocked_time = 0f;
				ClearNavigationPath(value);
			}
			if (((Vector3)(ref val2)).sqrMagnitude > 0f)
			{
				value.last_requested_dir = val2;
			}
			bool flag3 = navigation_holds.Contains(worm);
			bool flag4 = !flag2 || flag3 || worm.lockedMovement;
			bool flag5 = flag4 || Time.time < value.direction_grace_until || Time.time < value.cooldown_until;
			bool flag6 = IsAttackPressureForcing(worm);
			AttackPlan value2;
			bool flag7 = attack_plans.TryGetValue(worm, out value2) && value2.attack_run;
			bool flag8 = flag6 || committed_attack_runs.ContainsKey(worm) || flag7;
			bool include_buildings = !flag8;
			bool flag9 = flag4 || a.dive || flag6;
			if (flag9)
			{
				ClearNavigationPath(value);
			}
			if (a.dive || flag6)
			{
				value.surface_unstick_until = 0f;
			}
			else
			{
				if (!flag4 && text == "Surface" && Time.time < value.surface_unstick_until && num2 >= 0.55f)
				{
					a.move_x = value.surface_unstick_dir.x;
					a.move_y = value.surface_unstick_dir.z;
					StoreNavigationCommand(value, a);
					return;
				}
				if (num2 < 0.55f)
				{
					value.surface_unstick_until = 0f;
				}
			}
			bool num3 = text == "Surface" && !flag5 && !a.dive && !flag8 && num2 >= 0.55f && value.last_command_mag >= 0.55f;
			Vector3 hit_normal = Vector3.zero;
			if (num3)
			{
				float max_distance = Mathf.Clamp(3f + value.speed_ema * 0.3f, 3f, 9f);
				float num4 = ProbeObstacleDistance(worm, value.last_command_dir, max_distance, include_buildings, out hit_normal);
				bool flag10 = value.speed_ema < 1.25f && value.forward_speed_ema < 0.75f;
				bool flag11 = num4 <= 1.75f && flag10;
				value.low_motion_time = (flag10 ? (value.low_motion_time + num) : Mathf.Max(0f, value.low_motion_time - num * 2f));
				value.blocked_time = (flag11 ? (value.blocked_time + num) : Mathf.Max(0f, value.blocked_time - num * 2f));
				if (value.low_motion_time >= 1f || value.blocked_time >= 0.75f)
				{
					Vector3 val3 = BeginSurfaceUnstick(worm, value, hit_normal);
					a.move_x = val3.x;
					a.move_y = val3.z;
					StoreNavigationCommand(value, a);
					return;
				}
			}
			else
			{
				value.low_motion_time = 0f;
				value.blocked_time = 0f;
			}
			if (!flag9 && num2 >= 0.55f)
			{
				if (TryFollowNavigationPath(worm, value, text, val2, include_buildings, out var path_dir))
				{
					ResetAvoidance(value);
					a.move_x = path_dir.x * num2;
					a.move_y = path_dir.z * num2;
					if (value2 != null && !value2.attack_run && NavigationPathMakingProgress(value))
					{
						value2.expires_at = Mathf.Max(value2.expires_at, Time.time + 2f);
					}
				}
				else
				{
					Vector3 val4 = AvoidObstacle(worm, value, val2, include_buildings);
					a.move_x = val4.x * num2;
					a.move_y = val4.z * num2;
				}
			}
			else
			{
				ClearNavigationPath(value);
				ResetAvoidance(value);
			}
			StoreNavigationCommand(value, a);
		}

		private static bool IsAttackPressureForcing(WormMovement worm)
		{
			if (attack_pressure.TryGetValue(worm, out var value))
			{
				return value.forcing_since >= 0f;
			}
			return false;
		}

		private static float UpdateNavigationObservation(WormMovement worm, NavigationState nav)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			float time = Time.time;
			Vector3 position = ((Component)worm).transform.position;
			if (!nav.initialized || nav.last_tick <= 0f || time - nav.last_tick > 0.25f)
			{
				nav.initialized = true;
				nav.last_pos = position;
				nav.last_tick = time;
				nav.speed_ema = 0f;
				nav.forward_speed_ema = 0f;
				return Time.fixedDeltaTime;
			}
			float num = Mathf.Max(0.001f, time - nav.last_tick);
			Vector3 val = (position - nav.last_pos) / num;
			val.y = 0f;
			float magnitude = ((Vector3)(ref val)).magnitude;
			float num2 = ((((Vector3)(ref nav.last_command_dir)).sqrMagnitude > 0f) ? Vector3.Dot(val, nav.last_command_dir) : magnitude);
			float num3 = 1f - Mathf.Exp((0f - num) / 0.25f);
			nav.speed_ema = Mathf.Lerp(nav.speed_ema, magnitude, num3);
			nav.forward_speed_ema = Mathf.Lerp(nav.forward_speed_ema, num2, num3);
			nav.last_pos = position;
			nav.last_tick = time;
			return num;
		}

		private static void StoreNavigationCommand(NavigationState nav, WormAction a)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(a.move_x, 0f, a.move_y);
			nav.last_command_mag = Mathf.Clamp01(((Vector3)(ref val)).magnitude);
			if (nav.last_command_mag > 0.0001f)
			{
				nav.last_command_dir = ((Vector3)(ref val)).normalized;
			}
		}

		private static Vector3 BeginSurfaceUnstick(WormMovement worm, NavigationState nav, Vector3 hit_normal)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			dive_intents.Remove(worm);
			nav.surface_unstick_dir = ChooseRecoveryDirection(worm, nav.last_command_dir, hit_normal);
			nav.surface_unstick_until = Time.time + 0.6f;
			nav.cooldown_until = nav.surface_unstick_until + 0.75f;
			nav.low_motion_time = 0f;
			nav.blocked_time = 0f;
			ClearNavigationPath(nav);
			ResetAvoidance(nav);
			ResetMoveControllerDamping(worm);
			return nav.surface_unstick_dir;
		}

		private static Vector3 BeginSurfaceRecovery(WormMovement worm, Vector3 preferred_dir, out bool wants_burrow)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			if (!navigation_states.TryGetValue(worm, out var value))
			{
				value = new NavigationState();
				navigation_states[worm] = value;
			}
			attack_plans.Remove(worm);
			dive_intents.Remove(worm);
			navigation_holds.Remove(worm);
			preferred_dir.y = 0f;
			if (((Vector3)(ref preferred_dir)).sqrMagnitude < 0.0001f)
			{
				preferred_dir = -((Component)worm).transform.forward;
			}
			string text = SafeState(worm);
			bool flag = text == "Surface" || text == "TransitionFromBurrowedToSurface";
			value.phase = (flag ? RecoveryPhase.Surface : RecoveryPhase.Escape);
			value.phase_started = Time.time;
			value.recovery_started = Time.time;
			value.recovery_origin = ((Component)worm).transform.position;
			value.recovery_dir = ChooseRecoveryDirection(worm, -preferred_dir, Vector3.zero);
			value.clear_time = 0f;
			value.low_motion_time = 0f;
			value.blocked_time = 0f;
			ClearNavigationPath(value);
			value.surface_search = true;
			value.has_surface_target = false;
			if (!flag && TryFindSurfaceTarget(worm, 12f, out var target))
			{
				value.surface_target = target;
				value.has_surface_target = true;
				Vector3 val = target - ((Component)worm).transform.position;
				val.y = 0f;
				value.recovery_dir = ((Vector3)(ref val)).normalized;
			}
			wants_burrow = !flag;
			ResetMoveControllerDamping(worm);
			return value.recovery_dir;
		}

		private static void DriveRecovery(WormMovement worm, NavigationState nav, string state, float dt, ref WormAction a)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			a.dive = false;
			dive_intents.Remove(worm);
			attack_plans.Remove(worm);
			if (nav.phase == RecoveryPhase.Burrow)
			{
				a.move_x = nav.recovery_dir.x;
				a.move_y = nav.recovery_dir.z;
				desired_burrowed[worm] = true;
				if (state == "Burrowed")
				{
					nav.phase = RecoveryPhase.Escape;
					nav.phase_started = Time.time;
					nav.recovery_origin = ((Component)worm).transform.position;
					nav.clear_time = 0f;
				}
				else if (Time.time - nav.phase_started >= 1.5f)
				{
					nav.recovery_dir = ChooseRecoveryDirection(worm, nav.recovery_dir, Vector3.zero);
					nav.phase_started = Time.time;
				}
			}
			else if (nav.phase == RecoveryPhase.Escape)
			{
				Vector3 val = nav.recovery_dir;
				bool flag = false;
				if (nav.surface_search && nav.has_surface_target)
				{
					Vector3 delta = nav.surface_target - ((Component)worm).transform.position;
					delta.y = 0f;
					flag = ((Vector3)(ref delta)).sqrMagnitude <= 0.25f;
					val = (flag ? Vector3.zero : ArrivalMove(delta, 8f));
					if (((Vector3)(ref val)).sqrMagnitude > 0.0001f)
					{
						nav.recovery_dir = ((Vector3)(ref val)).normalized;
					}
				}
				a.move_x = val.x;
				a.move_y = val.z;
				desired_burrowed[worm] = true;
				Vector3 hit_normal;
				float num = ProbeObstacleDistance(worm, nav.recovery_dir, 3f, include_buildings: true, out hit_normal);
				nav.clear_time = ((num >= 3f) ? (nav.clear_time + dt) : 0f);
				Vector3 val2 = ((Component)worm).transform.position - nav.recovery_origin;
				val2.y = 0f;
				WormPlayer component = ((Component)worm).GetComponent<WormPlayer>();
				bool flag2 = (Object)(object)component != (Object)null && component.wormHealth < component.wormHealth_Max;
				float num2 = (nav.surface_search ? 0.25f : 0.4f);
				float num3 = (nav.surface_search ? 2f : 6f);
				if (!flag2 && (flag || (!nav.has_surface_target && Time.time - nav.phase_started >= num2 && ((Vector3)(ref val2)).magnitude >= num3 && nav.clear_time >= 0.25f)) && CanSurfaceHere(worm))
				{
					BeginRecoverySurface(worm, nav, ref a);
				}
				else
				{
					if (!(Time.time - nav.phase_started >= 1f))
					{
						return;
					}
					if (!flag2 && CanSurfaceHere(worm))
					{
						BeginRecoverySurface(worm, nav, ref a);
						return;
					}
					float max_radius = ((Time.time - nav.recovery_started >= 18f) ? 24f : 12f);
					if (TryFindSurfaceTarget(worm, max_radius, out var target))
					{
						nav.surface_target = target;
						nav.has_surface_target = true;
						Vector3 val3 = target - ((Component)worm).transform.position;
						val3.y = 0f;
						nav.recovery_dir = ((Vector3)(ref val3)).normalized;
					}
					else
					{
						nav.has_surface_target = false;
						nav.recovery_dir = Quaternion.AngleAxis(90f, Vector3.up) * nav.recovery_dir;
					}
					nav.phase_started = Time.time;
					nav.recovery_origin = ((Component)worm).transform.position;
					nav.clear_time = 0f;
				}
			}
			else
			{
				desired_burrowed[worm] = false;
				a.move_x = 0f;
				a.move_y = 0f;
				StopMoveController(worm);
				if (state == "Surface")
				{
					nav.phase = RecoveryPhase.None;
					nav.cooldown_until = Time.time + 0.75f;
					surfaced_time[worm] = Time.time;
					nav.low_motion_time = 0f;
					nav.blocked_time = 0f;
					nav.surface_search = false;
					nav.has_surface_target = false;
					ResetMoveControllerDamping(worm);
				}
				else if (Time.time - nav.phase_started >= 2f)
				{
					nav.phase = RecoveryPhase.Escape;
					nav.phase_started = Time.time;
					nav.recovery_origin = ((Component)worm).transform.position;
					nav.recovery_dir = Quaternion.AngleAxis(90f, Vector3.up) * nav.recovery_dir;
					nav.clear_time = 0f;
					nav.has_surface_target = false;
					desired_burrowed[worm] = true;
				}
			}
		}

		private static void BeginRecoverySurface(WormMovement worm, NavigationState nav, ref WormAction a)
		{
			nav.phase = RecoveryPhase.Surface;
			nav.phase_started = Time.time;
			nav.has_surface_target = false;
			a.move_x = 0f;
			a.move_y = 0f;
			StopMoveController(worm);
		}

		private static Vector3 ChooseRecoveryDirection(WormMovement worm, Vector3 command_dir, Vector3 hit_normal)
		{
			//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_006d: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			hit_normal.y = 0f;
			command_dir.y = 0f;
			Vector3 val = ((((Vector3)(ref hit_normal)).sqrMagnitude > 0.0001f) ? ((Vector3)(ref hit_normal)).normalized : ((((Vector3)(ref command_dir)).sqrMagnitude > 0.0001f) ? (-((Vector3)(ref command_dir)).normalized) : (-((Component)worm).transform.forward)));
			float[] obj = new float[8] { 0f, 45f, -45f, 90f, -90f, 135f, -135f, 180f };
			Vector3 val2 = val;
			float num = float.MinValue;
			float[] array = obj;
			for (int i = 0; i < array.Length; i++)
			{
				Vector3 val3 = Quaternion.AngleAxis(array[i], Vector3.up) * val;
				Vector3 hit_normal2;
				float num2 = ProbeObstacleDistance(worm, val3, 9f, include_buildings: true, out hit_normal2) + Vector3.Dot(val3, val) * 2f;
				if (num2 > num)
				{
					num = num2;
					val2 = val3;
				}
			}
			return ((Vector3)(ref val2)).normalized;
		}

		private static bool NavigationPathMakingProgress(WormMovement worm)
		{
			if (navigation_states.TryGetValue(worm, out var value))
			{
				return NavigationPathMakingProgress(value);
			}
			return false;
		}

		private static bool NavigationPathMakingProgress(NavigationState nav)
		{
			if (HasNavigationPath(nav) && nav.path_has_progress)
			{
				return Time.time - nav.path_progress_at <= 0.8f;
			}
			return false;
		}

		private static bool TryFollowNavigationPath(WormMovement worm, NavigationState nav, string state, Vector3 desired_dir, bool include_buildings, out Vector3 path_dir)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: 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_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			path_dir = Vector3.zero;
			bool flag = state == "Burrowed";
			bool flag2 = state == "Surface";
			bool has_destination;
			Vector3 destination;
			Vector3 val = ResolveNavigationPathGoal(worm, desired_dir, out has_destination, out destination);
			if (flag2 && TryGroundHit(val, out var hit))
			{
				val.y = ((RaycastHit)(ref hit)).point.y;
			}
			Vector3 val2 = val - ((Component)worm).transform.position;
			val2.y = 0f;
			if (((Vector3)(ref val2)).sqrMagnitude < 0.25f)
			{
				ClearNavigationPath(nav);
				return false;
			}
			if (HasNavigationPath(nav))
			{
				Vector3 val3 = destination - nav.path_destination;
				val3.y = 0f;
				bool flag3 = has_destination != nav.path_has_destination || (has_destination && ((Vector3)(ref val3)).sqrMagnitude > 36f);
				if (nav.path_burrowed != flag || nav.path_include_buildings != include_buildings || Vector3.Dot(desired_dir, nav.path_goal_dir) < 0.75f || flag3 || Time.time - nav.path_created_at >= 2.5f)
				{
					ClearNavigationPath(nav);
				}
			}
			if (HasNavigationPath(nav))
			{
				AdvanceNavigationPath(nav, ((Component)worm).transform.position);
			}
			if (HasNavigationPath(nav) && Time.time >= nav.path_next_check)
			{
				Vector3 probe_offset = NavigationProbeOrigin(worm) - ((Component)worm).transform.position;
				if (IsNavigationPathSegmentClear(worm, ((Component)worm).transform.position, val, probe_offset, flag2, include_buildings))
				{
					ClearNavigationPath(nav);
					return false;
				}
				for (int num = nav.path_waypoints.Count - 1; num > nav.path_index; num--)
				{
					if (IsNavigationPathSegmentClear(worm, ((Component)worm).transform.position, nav.path_waypoints[num], probe_offset, flag2, include_buildings))
					{
						nav.path_index = num;
						nav.path_best_distance = float.PositiveInfinity;
						nav.path_progress_at = Time.time;
						nav.path_has_progress = true;
						break;
					}
				}
				if (HasNavigationPath(nav) && !IsNavigationPathSegmentClear(worm, ((Component)worm).transform.position, nav.path_waypoints[nav.path_index], probe_offset, flag2, include_buildings))
				{
					ClearNavigationPath(nav);
				}
				nav.path_next_check = Time.time + 0.15f;
			}
			if (HasNavigationPath(nav))
			{
				AdvanceNavigationPath(nav, ((Component)worm).transform.position);
			}
			if (HasNavigationPath(nav))
			{
				Vector3 val4 = nav.path_waypoints[nav.path_index] - ((Component)worm).transform.position;
				val4.y = 0f;
				float magnitude = ((Vector3)(ref val4)).magnitude;
				if (magnitude <= nav.path_best_distance - 0.5f)
				{
					nav.path_best_distance = magnitude;
					nav.path_progress_at = Time.time;
					nav.path_has_progress = true;
				}
				if (Time.time - nav.path_progress_at <= 1f && magnitude > 0.0001f)
				{
					path_dir = val4 / magnitude;
					return true;
				}
				ClearNavigationPath(nav);
			}
			Vector3 probe_offset2 = NavigationProbeOrigin(worm) - ((Component)worm).transform.position;
			if (Time.time < nav.path_next_check || Time.time < nav.path_next_replan)
			{
				return false;
			}
			nav.path_next_check = Time.time + 0.15f;
			if (IsNavigationPathSegmentClear(worm, ((Component)worm).transform.position, val, probe_offset2, flag2, include_buildings))
			{
				return false;
			}
			if (!TryBuildNavigationPath(worm, nav, flag2, desired_dir, val, has_destination, destination, include_buildings, out var search_attempted))
			{
				if (search_attempted)
				{
					nav.path_next_replan = Time.time + 0.3f;
				}
				return false;
			}
			AdvanceNavigationPath(nav, ((Component)worm).transform.position);
			if (!HasNavigationPath(nav))
			{
				return false;
			}
			Vector3 val5 = nav.path_waypoints[nav.path_index] - ((Component)worm).transform.position;
			val5.y = 0f;
			if (((Vector3)(ref val5)).sqrMagnitude < 0.0001f)
			{
				ClearNavigationPath(nav);
				return false;
			}
			path_dir = ((Vector3)(ref val5)).normalized;
			return true;
		}

		private static void AdvanceNavigationPath(NavigationState nav, Vector3 current_pos)
		{
			//IL_0011: 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_0020: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			while (HasNavigationPath(nav))
			{
				Vector3 val = nav.path_waypoints[nav.path_index];
				Vector3 val2 = ((nav.path_index > 0) ? nav.path_waypoints[nav.path_index - 1] : nav.path_start);
				Vector3 val3 = val - current_pos;
				Vector3 val4 = val - val2;
				Vector3 val5 = current_pos - val2;
				val3.y = 0f;
				val4.y = 0f;
				val5.y = 0f;
				bool num = ((Vector3)(ref val3)).sqrMagnitude <= 2.25f;
				float num2 = ((((Vector3)(ref val4)).sqrMagnitude > 0.0001f) ? Vector3.Dot(val5, val4) : 0f);
				Vector3 val6 = ((((Vector3)(ref val4)).sqrMagnitude > 0.0001f) ? (val5 - val4 * (num2 / ((Vector3)(ref val4)).sqrMagnitude)) : val5);
				bool flag = num2 >= ((Vector3)(ref val4)).sqrMagnitude && ((Vector3)(ref val6)).sqrMagnitude <= 16f;
				if (!num && !flag)
				{
					break;
				}
				nav.path_index++;
				nav.path_progress_at = Time.time;
				nav.path_best_distance = float.PositiveInfinity;
				nav.path_next_check = 0f;
				nav.path_has_progress = true;
			}
			if (!HasNavigationPath(nav))
			{
				ClearNavigationPath(nav);
			}
		}

		private static Vector3 ResolveNavigationPathGoal(WormMovement worm, Vector3 desired_dir, out bool has_destination, out Vector3 destination)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00ac: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)worm).transform.position;
			has_destination = TryNavigationDestination(worm, out destination);
			Vector3 val = (has_destination ? (destination - position) : (desired_dir * 28f));
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude < 0.25f || Vector3.Dot(((Vector3)(ref val)).normalized, desired_dir) < 0.5f)
			{
				has_destination = false;
				destination = position + desired_dir * 28f;
				val = desired_dir * 28f;
			}
			float num = Mathf.Min(((Vector3)(ref val)).magnitude, 28f);
			Vector3 result = position + ((Vector3)(ref val)).normalized * num;
			result.y = position.y;
			return result;
		}

		private static bool TryNavigationDestination(WormMovement worm, out Vector3 destination)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (attack_plans.TryGetValue(worm, out var value))
			{
				if (!value.attack_run)
				{
					destination = value.setup_pos;
					return true;
				}
				if (!value.launch_reached)
				{
					destination = value.launch_pos;
					return true;
				}
			}
			return navigation_goals.TryGetValue(worm, out destination);
		}

		private static bool TryBuildNavigationPath(WormMovement worm, NavigationState nav, bool surfaced, Vector3 desired_dir, Vector3 goal, bool has_destination, Vector3 destination, bool include_buildings, out bool search_attempted)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			search_attempted = false;
			if (navigation_path_search_frame == Time.frameCount)
			{
				return false;
			}
			navigation_path_search_frame = Time.frameCount;
			search_attempted = true;
			Vector3 position = ((Component)worm).transform.position;
			Vector3 val = goal - position;
			val.y = 0f;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 3f)
			{
				return false;
			}
			Vector3 val2 = val / magnitude;
			Vector3 right = default(Vector3);
			((Vector3)(ref right))..ctor(val2.z, 0f, 0f - val2.x);
			Vector3 probe_offset = NavigationProbeOrigin(worm) - position;
			ResetNavigationPathSearch();
			int num = NavigationPathIndex(8, 8);
			if (!IsNavigationPathPositionClear(worm, position, probe_offset, include_buildings))
			{
				return false;
			}
			navigation_path_positions[num] = position;
			navigation_path_node_state[num] = 1;
			int num2 = Mathf.Clamp(Mathf.RoundToInt(magnitude / 4f), 1, 8);
			if (MarkNavigationPathGoals(worm, position, val2, right, probe_offset, surfaced, include_buildings, 8, 8 + num2) == 0)
			{
				return false;
			}
			navigation_path_g[num] = 0f;
			navigation_path_f[num] = NavigationPathGoalHeuristic(num);
			navigation_path_search_state[num] = 1;
			int num3 = -1;
			int num4 = 0;
			while (num4 < 192)
			{
				int num5 = FindLowestNavigationPathOpen();
				if (num5 < 0)
				{
					break;
				}
				if (navigation_path_goal_state[num5] == 1)
				{
					num3 = num5;
					break;
				}
				navigation_path_search_state[num5] = 2;
				num4++;
				int num6 = NavigationPathX(num5);
				int num7 = NavigationPathZ(num5);
				for (int i = -1; i <= 1; i++)
				{
					for (int j = -1; j <= 1; j++)
					{
						if (j == 0 && i == 0)
						{
							continue;
						}
						int num8 = num6 + j;
						int num9 = num7 + i;
						if (num8 < 0 || num8 >= 17 || num9 < 0 || num9 >= 17)
						{
							continue;
						}
						int num10 = NavigationPathIndex(num8, num9);
						if (navigation_path_search_state[num10] == 2 || !TryNavigationPathNode(worm, num10, position, val2, right, probe_offset, surfaced, include_buildings) || !IsNavigationGridEdgeClear(worm, num5, num10, navigation_path_positions[num5], navigation_path_positions[num10], probe_offset, surfaced, include_buildings))
						{
							continue;
						}
						Vector2 val3 = new Vector2((float)j, (float)i);
						float num11 = ((Vector2)(ref val3)).magnitude * 4f;
						if (num9 < num7)
						{
							num11 += 0.75f;
						}
						int num12 = navigation_path_parent[num5];
						if (num12 >= 0)
						{
							int num13 = num6 - NavigationPathX(num12);
							int num14 = num7 - NavigationPathZ(num12);
							if (num13 != j || num14 != i)
							{
								num11 += 0.6f;
							}
						}
						float num15 = navigation_path_g[num5] + num11;
						if (navigation_path_search_state[num10] != 1 || num15 < navigation_path_g[num10])
						{
							navigation_path_parent[num10] = num5;
							navigation_path_g[num10] = num15;
							float num16 = ((navigation_path_goal_state[num10] == 1) ? navigation_path_goal_penalty[num10] : NavigationPathGoalHeuristic(num10));
							navigation_path_f[num10] = num15 + num16;
							navigation_path_search_state[num10] = 1;
						}
					}
				}
			}
			if (num3 < 0)
			{
				return false;
			}
			List<Vector3> list = new List<Vector3>();
			int num17 = num3;
			int num18 = 0;
			while (num17 != num && num17 >= 0 && num18 < 289)
			{
				list.Add(navigation_path_positions[num17]);
				num17 = navigation_path_parent[num17];
				num18++;
			}
			if (num17 != num || list.Count == 0)
			{
				return false;
			}
			list.Reverse();
			SmoothNavigationPath(worm, list, nav.path_waypoints, probe_offset, surfaced, include_buildings);
			if (nav.path_waypoints.Count == 0)
			{
				return false;
			}
			nav.path_index = 0;
			nav.path_start = position;
			nav.path_destination = destination;
			nav.path_goal_dir = desired_dir;
			nav.path_has_destination = has_destination;
			nav.path_burrowed = !surfaced;
			nav.path_include_buildings = include_buildings;
			nav.path_created_at = Time.time;
			nav.path_progress_at = Time.time;
			Vector3 val4 = nav.path_waypoints[0] - position;
			val4.y = 0f;
			nav.path_best_distance = ((Vector3)(ref val4)).magnitude;
			nav.path_next_check = Time.time + 0.15f;
			nav.path_next_replan = Time.time + 0.3f;
			nav.path_has_progress = false;
			return true;
		}

		private static void ResetNavigationPathSearch()
		{
			for (int i = 0; i < 289; i++)
			{
				navigation_path_g[i] = float.PositiveInfinity;
				navigation_path_f[i] = float.PositiveInfinity;
				navigation_path_parent[i] = -1;
				navigation_path_search_state[i] = 0;
				navigation_path_node_state[i] = 0;
				navigation_path_goal_state[i] = 0;
				navigation_path_goal_penalty[i] = float.PositiveInfinity;
				int num = i * 4;
				navigation_path_edge_state[num] = 0;
				navigation_path_edge_state[num + 1] = 0;
				navigation_path_edge_state[num + 2] = 0;
				navigation_path_edge_state[num + 3] = 0;
			}
		}

		private static int MarkNavigationPathGoals(WormMovement worm, Vector3 start, Vector3 forward, Vector3 right, Vector3 probe_offset, bool surfaced, bool include_buildings, int goal_x, int goal_z)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			for (int i = -2; i <= 2; i++)
			{
				for (int j = -2; j <= 2; j++)
				{
					int num2 = goal_x + j;
					int num3 = goal_z + i;
					if (num2 < 0 || num2 >= 17 || num3 <= 8 || num3 >= 17)
					{
						continue;
					}
					int num4 = NavigationPathIndex(num2, num3);
					if (TryNavigationPathNode(worm, num4, start, forward, right, probe_offset, surfaced, include_buildings))
					{
						Vector2 val = new Vector2((float)j, (float)i);
						float num5 = ((Vector2)(ref val)).magnitude * 4f * 2f;
						if (i < 0)
						{
							num5 += 1f;
						}
						navigation_path_goal_state[num4] = 1;
						navigation_path_goal_penalty[num4] = num5;
						num++;
					}
				}
			}
			return num;
		}

		private static int FindLowestNavigationPathOpen()
		{
			int result = -1;
			float num = float.PositiveInfinity;
			for (int i = 0; i < 289; i++)
			{
				if (navigation_path_search_state[i] == 1 && navigation_path_f[i] < num)
				{
					num = navigation_path_f[i];
					result = i;
				}
			}
			return result;
		}

		private static float NavigationPathGoalHeuristic(int from)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			float num = float.PositiveInfinity;
			for (int i = 0; i < 289; i++)
			{
				if (navigation_path_goal_state[i] != 0)
				{
					float num2 = NavigationPathX(i) - NavigationPathX(from);
					float num3 = NavigationPathZ(i) - NavigationPathZ(from);
					Vector2 val = new Vector2(num2, num3);
					float num4 = ((Vector2)(ref val)).magnitude * 4f + navigation_path_goal_penalty[i];
					if (num4 < num)
					{
						num = num4;
					}
				}
			}
			return num;
		}

		private static int NavigationPathIndex(int x, int z)
		{
			return z * 17 + x;
		}

		private static int NavigationPathX(int index)
		{
			return index % 17;
		}

		private static int NavigationPathZ(int index)
		{
			return index / 17;
		}

		private static bool TryNavigationPathNode(WormMovement worm, int index, Vector3 start, Vector3 forward, Vector3 right, Vector3 probe_offset, bool surfaced, bool include_buildings)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_003f: 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_004d: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			if (navigation_path_node_state[index] == 1)
			{
				return true;
			}
			if (navigation_path_node_state[index] == 2)
			{
				return false;
			}
			int num = NavigationPathX(index) - 8;
			int num2 = NavigationPathZ(index) - 8;
			Vector3 val = start + right * ((float)num * 4f) + forward * ((float)num2 * 4f);
			if (surfaced)
			{
				if (!TryGroundHit(val, out var hit) || ((RaycastHit)(ref hit)).normal.y < 0.6f)
				{
					navigation_path_node_state[index] = 2;
					return false;
				}
				val.y = ((RaycastHit)(ref hit)).point.y;
			}
			else
			{
				val.y = start.y;
			}
			if (!IsNavigationPathPositionClear(worm, val, probe_offset, include_buildings))
			{
				navigation_path_node_state[index] = 2;
				return false;
			}
			navigation_path_positions[index] = val;
			navigation_path_node_state[index] = 1;
			return true;
		}

		private static bool IsNavigationPathPositionClear(WormMovement worm, Vector3 position, Vector3 probe_offset, bool include_buildings)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			int num = Physics.OverlapSphereNonAlloc(position + probe_offset, 2f, navigation_path_overlap_hits, attack_obstacle_mask, (QueryTriggerInteraction)1);
			for (int i = 0; i < num; i++)
			{
				if (IsNavigationObstacle(worm, navigation_path_overlap_hits[i], include_buildings))
				{
					return false;
				}
			}
			return num < navigation_path_overlap_hits.Length;
		}

		private static bool IsNavigationGridEdgeClear(WormMovement worm, int from_index, int to_index, Vector3 from, Vector3 to, Vector3 probe_offset, bool surfaced, bool include_buildings)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			int num = NavigationPathX(from_index);
			int num2 = NavigationPathZ(from_index);
			int num3 = NavigationPathX(to_index);
			int num4 = NavigationPathZ(to_index);
			int x;
			int z;
			int num5;
			if (num2 == num4)
			{
				x = Mathf.Min(num, num3);
				z = num2;
				num5 = 0;
			}
			else if (num == num3)
			{
				x = num;
				z = Mathf.Min(num2, num4);
				num5 = 1;
			}
			else if (num3 - num == num4 - num2)
			{
				x = Mathf.Min(num, num3);
				z = Mathf.Min(num2, num4);
				num5 = 2;
			}
			else
			{
				x = Mathf.Min(num, num3);
				z = Mathf.Max(num2, num4);
				num5 = 3;
			}
			int num6 = NavigationPathIndex(x, z) * 4 + num5;
			if (navigation_path_edge_state[num6] != 0)
			{
				return navigation_path_edge_state[num6] == 1;
			}
			bool flag = IsNavigationPathSegmentClear(worm, from, to, probe_offset, surfaced, include_buildings);
			navigation_path_edge_state[num6] = (byte)(flag ? 1 : 2);
			return flag;
		}

		private static bool IsNavigationPathSegmentClear(WormMovement worm, Vector3 from, Vector3 to, Vector3 probe_offset, bool surfaced, bool include_buildings)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			if (surfaced)
			{
				return IsNavigationSurfacePathClear(worm, from, to, probe_offset, include_buildings);
			}
			return IsNavigationPathSweepClear(worm, from, to, probe_offset, include_buildings);
		}

		private static bool IsNavigationPathSweepClear(WormMovement worm, Vector3 from, Vector3 to, Vector3 probe_offset, bool include_buildings)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = to - from;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 0.1f)
			{
				return true;
			}
			int num = Physics.SphereCastNonAlloc(from + probe_offset, 2f, val / magnitude, navigation_path_cast_hits, magnitude, attack_obstacle_mask, (QueryTriggerInteraction)1);
			for (int i = 0; i < num; i++)
			{
				if (IsNavigationObstacle(worm, ((RaycastHit)(ref navigation_path_cast_hits[i])).collider, include_buildings))
				{
					return false;
				}
			}
			return num < navigation_path_cast_hits.Length;
		}

		private static bool IsNavigationSurfacePathClear(WormMovement worm, Vector3 from, Vector3 to, Vector3 probe_offset, bool include_buildings)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = to - from;
			val.y = 0f;
			int num = Mathf.Max(1, Mathf.CeilToInt(((Vector3)(ref val)).magnitude / 4f));
			Vector3 val2 = from;
			for (int i = 1; i <= num; i++)
			{
				Vector3 val3 = Vector3.Lerp(from, to, (float)i / (float)num);
				if (!TryGroundHit(val3, out var hit) || ((RaycastHit)(ref hit)).normal.y < 0.6f || Mathf.Abs(((RaycastHit)(ref hit)).point.y - val2.y) > 2.5f)
				{
					return false;
				}
				val3.y = ((RaycastHit)(ref hit)).point.y;
				if (!IsNavigationPathSweepClear(worm, val2, val3, probe_offset, include_buildings))
				{
					return false;
				}
				val2 = val3;
			}
			return true;
		}

		private static void SmoothNavigationPath(WormMovement worm, List<Vector3> raw_path, List<Vector3> smoothed_path, Vector3 probe_offset, bool surfaced, bool include_buildings)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			smoothed_path.Clear();
			Vector3 val = ((Component)worm).transform.position;
			int num = 0;
			while (num < raw_path.Count)
			{
				int num2 = num;
				for (int num3 = raw_path.Count - 1; num3 >= num; num3--)
				{
					if (IsNavigationPathSegmentClear(worm, val, raw_path[num3], probe_offset, surfaced, include_buildings))
					{
						num2 = num3;
						break;
					}
				}
				smoothed_path.Add(raw_path[num2]);
				val = raw_path[num2];
				num = num2 + 1;
			}
		}

		private static bool HasNavigationPath(NavigationState nav)
		{
			if (nav.path_index >= 0)
			{
				return nav.path_index < nav.path_waypoints.Count;
			}
			return false;
		}

		private static void ClearNavigationPath(NavigationState nav)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			nav.path_waypoints.Clear();
			nav.path_index = 0;
			nav.path_start = Vector3.zero;
			nav.path_destination = Vector3.zero;
			nav.path_goal_dir = Vector3.zero;
			nav.path_has_destination = false;
			nav.path_created_at = 0f;
			nav.path_progress_at = 0f;
			nav.path_best_distance = 0f;
			nav.path_next_check = 0f;
			nav.path_has_progress = false;
		}

		private static Vector3 AvoidObstacle(WormMovement worm, NavigationState nav, Vector3 desired_dir, bool include_buildings)
		{
			//IL_0023: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: 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_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp(3f + nav.speed_ema * 0.3f, 3f, 9f);
			Vector3 hit_normal;
			float num2 = ProbeObstacleDistance(worm, desired_dir, num, include_buildings, out hit_normal);
			float strength;
			Vector3 val = NearbyObstaclePressure(worm, desired_dir, include_buildings, out strength);
			Vector3 val2 = val - desired_dir * Vector3.Dot(val, desired_dir);
			if (((Vector3)(ref val2)).sqrMagnitude > 0.0001f)
			{
				((Vector3)(ref val2)).Normalize();
			}
			bool num3 = num2 < num || strength > 0.05f;
			bool flag = ((Vector3)(ref nav.avoid_dir)).sqrMagnitude > 0.0001f;
			if (!num3)
			{
				if (flag)
				{
					if (nav.avoid_clear_since <= 0f)
					{
						nav.avoid_clear_since = Time.time;
					}
					if ((Time.time < nav.avoid_until || Time.time - nav.avoid_clear_since < 0.3f) && Vector3.Dot(nav.avoid_dir, desired_dir) > -0.25f && ProbeObstacleDistance(worm, nav.avoid_dir, num, include_buildings, out hit_normal) > 1.75f)
					{
						return BlendAvoidance(desired_dir, nav.avoid_dir, 0.35f);
					}
				}
				ResetAvoidance(nav);
				return desired_dir;
			}
			nav.avoid_clear_since = 0f;
			float num4 = Mathf.Clamp01(Mathf.Max(strength, 1f - num2 / Mathf.Max(0.01f, num)));
			if (Time.time < nav.avoid_until && flag && Vector3.Dot(nav.avoid_dir, desired_dir) > -0.25f && ProbeObstacleDistance(worm, nav.avoid_dir, num, include_buildings, out hit_normal) > 1.75f)
			{
				return BlendAvoidance(desired_dir, nav.avoid_dir, Mathf.Lerp(0.55f, 0.95f, num4));
			}
			Vector3 val3 = -desired_dir;
			float num5 = float.MinValue;
			Vector3 val4 = Vector3.zero;
			float num6 = float.MinValue;
			float num7 = 0f;
			int avoid_side = nav.avoid_side;
			float[] array = navigation_avoid_angles;
			foreach (float num8 in array)
			{
				Vector3 val5 = Quaternion.AngleAxis(num8, Vector3.up) * desired_dir;
				float num9 = ProbeObstacleDistance(worm, val5, num, include_buildings, out hit_normal);
				int num10 = ((num8 > 0f) ? 1 : ((num8 < 0f) ? (-1) : 0));
				float num11 = ((num10 != 0 && num10 == nav.avoid_side) ? 0.75f : 0f);
				float num12 = ((((Vector3)(ref val2)).sqrMagnitude > 0f) ? (Vector3.Dot(val5, val2) * strength * 3f) : 0f);
				float num13 = num9 + Vector3.Dot(val5, desired_dir) * 2f + num11 + num12;
				if (num13 > num5)
				{
					num5 = num13;
					val3 = val5;
					avoid_side = num10;
				}
				if (nav.avoid_side != 0 && num10 == nav.avoid_side && num13 > num6)
				{
					num6 = num13;
					val4 = val5;
					num7 = num9;
				}
			}
			if (num7 > 1.75f && num6 >= num5 - 1.25f)
			{
				val3 = val4;
				avoid_side = nav.avoid_side;
			}
			nav.avoid_dir = ((Vector3)(ref val3)).normalized;
			nav.avoid_until = Time.time + 0.65f;
			nav.avoid_side = avoid_side;
			return BlendAvoidance(desired_dir, nav.avoid_dir, Mathf.Lerp(0.55f, 0.95f, num4));
		}

		private static Vector3 BlendAvoidance(Vector3 desired_dir, Vector3 avoid_dir, float weight)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.Lerp(desired_dir, avoid_dir, Mathf.Clamp01(weight));
			if (!(((Vector3)(ref val)).sqrMagnitude > 0.0001f))
			{
				return ((Vector3)(ref avoid_dir)).normalized;
			}
			return ((Vector3)(ref val)).normalized;
		}

		private static Vector3 NearbyObstaclePressure(WormMovement worm, Vector3 desired_dir, bool include_buildings, out float strength)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0081: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = NavigationProbeOrigin(worm);
			int num = Physics.OverlapSphereNonAlloc(val, 3.25f, navigation_overlap_hits, attack_obstacle_mask, (QueryTriggerInteraction)1);
			Vector3 val2 = Vector3.zero;
			for (int i = 0; i < num; i++)
			{
				Collider val3 = navigation_overlap_hits[i];
				if (!IsNavigationObstacle(worm, val3, include_buildings))
				{
					continue;
				}
				Vector3 val4 = val3.ClosestPoint(val) - val;
				val4.y = 0f;
				float num2 = ((Vector3)(ref val4)).magnitude;
				if (num2 < 0.05f)
				{
					Bounds bounds = val3.bounds;
					val4 = ((Bounds)(ref bounds)).center - val;
					val4.y = 0f;
					num2 = ((Vector3)(ref val4)).magnitude;
				}
				if (num2 < 0.05f)
				{
					val4 = desired_dir;
					num2 = 0f;
				}
				Vector3 normalized = ((Vector3)(ref val4)).normalized;
				float num3 = Vector3.Dot(normalized, desired_dir);
				if (!(num3 < -0.25f) || !(num2 > 1.75f))
				{
					float num4 = 1f - Mathf.Clamp01(num2 / 3.25f);
					float num5 = Mathf.Clamp01((num3 + 0.25f) / 1.25f);
					float num6 = num4 * Mathf.Lerp(0.35f, 1f, num5);
					if (num2 <= 1.75f)
					{
						num6 = Mathf.Max(num6, 0.75f);
					}
					val2 -= normalized * num6;
				}
			}
			val2.y = 0f;
			strength = Mathf.Clamp01(((Vector3)(ref val2)).magnitude);
			if (!(((Vector3)(ref val2)).sqrMagnitude > 0.0001f))
			{
				return Vector3.zero;
			}
			return ((Vector3)(ref val2)).normalized;
		}

		private static void ResetAvoidance(NavigationState nav)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			nav.avoid_dir = Vector3.zero;
			nav.avoid_until = 0f;
			nav.avoid_clear_since = 0f;
			nav.avoid_side = 0;
		}

		private static float ProbeObstacleDistance(WormMovement worm, Vector3 direction, float max_distance, bool include_buildings, out Vector3 hit_normal)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			hit_normal = Vector3.zero;
			direction.y = 0f;
			if (((Vector3)(ref direction)).sqrMagnitude < 0.0001f)
			{
				return max_distance;
			}
			((Vector3)(ref direction)).Normalize();
			int num = Physics.SphereCastNonAlloc(NavigationProbeOrigin(worm), 1.75f, direction, navigation_cast_hits, max_distance, attack_obstacle_mask, (QueryTriggerInteraction)1);
			float num2 = max_distance;
			for (int i = 0; i < num; i++)
			{
				RaycastHit val = navigation_cast_hits[i];
				if (IsNavigationObstacle(worm, ((RaycastHit)(ref val)).collider, include_buildings) && ((RaycastHit)(ref val)).distance < num2)
				{
					num2 = ((RaycastHit)(ref val)).distance;
					hit_normal = ((RaycastHit)(ref val)).normal;
				}
			}
			return num2;
		}

		private static Vector3 NavigationProbeOrigin(WormMovement worm)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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)
			Collider component = ((Component)worm).GetComponent<Collider>();
			if (!((Object)(object)component != (Object)null))
			{
				return ((Component)worm).transform.position + Vector3.up * 1.25f;
			}
			Bounds bounds = component.bounds;
			return ((Bounds)(ref bounds)).center;
		}

		private static bool IsNavigationObstacle(WormMovement worm, Collider col, bool include_buildings)
		{
			if ((Object)(object)col == (Object)null || col.isTrigger || ((Component)col).gameObject.layer == LayerMask.NameToLayer("Ground"))
			{
				return false;
			}
			if ((Object)(object)GameManager.Singleton != (Object)null && (Object)(object)col == (Object)(object)GameManager.Singleton.duplicateWormOnlyTerrain_Collider)
			{
				return false;
			}
			if ((Object)(object)((Component)col).GetComponentInParent<WormMovement>() != (Object)null || (Object)(object)((Component)col).GetComponentInParent<Player>() != (Object)null || (Object)(object)((Component)col).GetComponentInParent<PickUppable>() != (Object)null)
			{
				return false;
			}
			if (!include_buildings && (Object)(object)((Component)col).GetComponentInParent<CollapsibleBuilding>() != (Object)null)
			{
				return false;
			}
			return true;
		}

		private static bool TryGroundClearing(WormMovement worm, Vector3 candidate, out Vector3 ground_pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: 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)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			ground_pos = Vector3.zero;
			if ((Object)(object)GameManager.Singleton == (Object)null)
			{
				return false;
			}
			Collider component = ((Component)worm).GetComponent<Collider>();
			float num;
			if (!((Object)(object)component != (Object)null))
			{
				num = 1f;
			}
			else
			{
				Bounds bounds = component.bounds;
				float x = ((Bounds)(ref bounds)).extents.x;
				bounds = component.bounds;
				num = Mathf.Max(x, ((Bounds)(ref bounds)).extents.z);
			}
			float num2 = Mathf.Clamp(num + 1f, 2f, 3f);
			if (!TryGroundHit(candidate, out var hit) || ((RaycastHit)(ref hit)).normal.y < 0.8f)
			{
				return false;
			}
			ground_pos = new Vector3(candidate.x, ((RaycastHit)(ref hit)).point.y, candidate.z);
			for (int i = 0; i < 8; i++)
			{
				float num3 = (float)i * MathF.PI * 2f / 8f;
				if (!TryGroundHit(ground_pos + new Vector3(Mathf.Cos(num3), 0f, Mathf.Sin(num3)) * num2, out var hit2) || Mathf.Abs(((RaycastHit)(ref hit2)).point.y - ground_pos.y) > 1.5f)
				{
					return false;
				}
			}
			Vector3 val = ground_pos + Vector3.up * (num2 + 0.15f);
			Vector3 val2 = val + Vector3.up * 2f;
			int num4 = Physics.OverlapCapsuleNonAlloc(val, val2, num2, clearing_overlap_hits, attack_obstacle_mask, (QueryTriggerInteraction)1);
			for (int j = 0; j < num4; j++)
			{
				if (IsClearingObstacle(clearing_overlap_hits[j]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool CanSurfaceHere(WormMovement worm)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return CanSurfaceAt(worm, ((Component)worm).transform.position);
		}

		private static bool CanSurfaceAt(WormMovement worm, Vector3 pos)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)GameManager.Singleton == (Object)null)
			{
				return false;
			}
			if (!TryGroundHit(pos, out var hit))
			{
				return false;
			}
			int num = Physics.OverlapSphereNonAlloc(new Vector3(pos.x, ((RaycastHit)(ref hit)).point.y + 0.2f, pos.z), 1.25f, clearing_overlap_hits, attack_obstacle_mask, (QueryTriggerInteraction)1);
			for (int i = 0; i < num; i++)
			{
				if (IsClearingObstacle(clearing_overlap_hits[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool TryFindSurfaceTarget(WormMovement worm, float max_radius, out Vector3 target)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			target = Vector3.zero;
			Vector3 position = ((Component)worm).transform.position;
			Vector3 val = default(Vector3);
			for (float num = 4f; num <= max_radius; num += 4f)
			{
				for (int i = 0; i < 8; i++)
				{
					float num2 = (float)i * MathF.PI * 2f / 8f;
					((Vector3)(ref val))..ctor(Mathf.Cos(num2), 0f, Mathf.Sin(num2));
					Vector3 val2 = position + val * num;
					if (ProbeObstacleDistance(worm, val, num, include_buildings: true, out var _) >= num - 0.1f && CanSurfaceAt(worm, val2))
					{
						target = val2;
						return true;
					}
				}
			}
			return false;
		}

		private static bool IsAttackRunClear(WormMovement worm, Vector3 setup_pos, Vector3 launch_pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = setup_pos + Vector3.up * 1.5f;
			Vector3 val2 = launch_pos + Vector3.up * 1.5f - val;
			float magnitude = ((Vector3)(ref val2)).magnitude;
			if (magnitude < 0.1f)
			{
				return true;
			}
			float y = setup_pos.y;
			for (int i = 1; i <= 2; i++)
			{
				if (!TryGroundHit(Vector3.Lerp(setup_pos, launch_pos, (float)i / 3f), out var hit) || Mathf.Abs(((RaycastHit)(ref hit)).point.y - y) > 1.5f)
				{
					return false;
				}
				y = ((RaycastHit)(ref hit)).point.y;
			}
			if (Mathf.Abs(launch_pos.y - y) > 1.5f)
			{
				return false;
			}
			int num = Physics.SphereCastNonAlloc(val, 1.5f, val2 / magnitude, attack_run_hits, magnitude, attack_obstacle_mask, (QueryTriggerInteraction)1);
			for (int j = 0; j < num; j++)
			{
				if (IsClearingObstacle(((RaycastHit)(ref attack_run_hits[j])).collider))
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsClearingObstacle(Collider col)
		{
			if ((Object)(object)col == (Object)null || ((Component)col).gameObject.layer == LayerMask.NameToLayer("Ground"))
			{
				return false;
			}
			if ((Object)(object)GameManager.Singleton != (Object)null && (Object)(object)col == (Object)(object)GameManager.Singleton.duplicateWormOnlyTerrain_Collider)
			{
				return false;
			}
			if ((Object)(object)((Component)col).GetComponentInParent<WormPlayer>() != (Object)null || (Object)(object)((Component)col).GetComponentInParent<Player>() != (Object)null)
			{
				return false;
			}
			return true;
		}

		private static Vector3 ArrivalMove(Vector3 delta, float slow_radius)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			delta.y = 0f;
			float magnitude = ((Vector3)(ref delta)).magnitude;
			if (magnitude < 0.0001f)
			{
				return Vector3.zero;
			}
			float num = Mathf.Clamp01(magnitude / slow_radius);
			return delta / magnitude * num;
		}

		private static void ApplySnakeAbilityPolicy(WormMovement worm, WormAbilityManager mgr, WormAction a)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Invalid comparison between Unknown and I4
			if (a.abilities == null)
			{
				return;
			}
			int num = -1;
			for (int i = 0; i < a.abilities.Length; i++)
			{
				if (AbilityInSlot(mgr, i) is WormAbility_BileBomb)
				{
					num = i;
				}
				a.abilities[i] = false;
			}
			if (num < 0)
			{
				return;
			}
			if (!snake_next_bile.TryGetValue(worm, out var value))
			{
				snake_next_bile[worm] = Time.time + Random.Range(5f, 15f);
			}
			else if (!(Time.time < value))
			{
				WormAbility val = AbilityInSlot(mgr, num);
				WormPlayer component = ((Component)worm).GetComponent<WormPlayer>();
				WormMouth componentInChildren = ((Component)worm).GetComponentInChildren<WormMouth>(true);
				if ((Object)(object)val != (Object)null && val.canUseAbility && (Object)(object)component != (Object)null && component.aboveGround.Value && ((Object)(object)componentInChildren == (Object)null || (int)componentInChildren.thingInMouthType.Value == 0))
				{
					a.abilities[num] = true;
					snake_next_bile[worm] = Time.time + Random.Range(5f, 15f);
				}
			}
		}

		private static Vector3 BackAwayDirection(WormMovement worm, Vector3 toward_target)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			toward_target.y = 0f;
			Vector3 val = ((((Vector3)(ref toward_target)).sqrMagnitude > 0.0001f) ? (-((Vector3)(ref toward_target)).normalized) : (-GetBodyForward(worm)));
			val.y = 0f;
			if (!(((Vector3)(ref val)).sqrMagnitude > 0.0001f))
			{
				return Vector3.back;
			}
			return ((Vector3)(ref val)).normalized;
		}

		private static void QueueLostSightAbility(WormMovement worm, Player target, string movement_state, Vector3 target_delta, ref WormAction action)
		{
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			bool flag = WormPerception.IsVisible(target);
			if (!lost_sight_abilities.TryGetValue(worm, out var value))
			{
				value = new LostSightAbilityState
				{
					target = target,
					was_visible = flag
				};
				lost_sight_abilities[worm] = value;
				return;
			}
			if ((Object)(object)value.target != (Object)(object)target)
			{
				value.target = target;
				value.was_visible = flag;
				value.pending = false;
				value.queued_slot = -1;
				return;
			}
			if (flag)
			{
				value.was_visible = true;
				value.pending = false;
				value.queued_slot = -1;
				return;
			}
			if (value.was_visible && WormPerception.TimeSinceSeen(worm, target) >= 3f)
			{
				value.was_visible = false;
				value.pending = true;
				Plugin.log.LogInfo((object)($"[worm] target unseen for {3f:F1}s; " + "search ability pending"));
			}
			if ((!value.pending && value.queued_slot < 0) || action.abilities == null)
			{
				return;
			}
			WormAbilityManager component = ((Component)worm).GetComponent<WormAbilityManager>();
			int slot_index = value.queued_slot;
			WormAbility ability = ((slot_index >= 0) ? AbilityInSlot(component, slot_index) : null);
			if (slot_index >= 0 && ((Object)(object)ability == (Object)null || !ability.canUseAbility || !CanUseLostSightAbility(worm, ability, movement_state)))
			{
				value.queued_slot = -1;
				slot_index = -1;
				ability = null;
			}
			bool flag2 = false;
			if ((slot_index < 0 && !TryFindLostSightAbility(worm, component, movement_state, out slot_index, out ability)) || slot_index < 0 || slot_index >= action.abilities.Length)
			{
				return;
			}
			if ((Object)(object)ability == (Object)null)
			{
				value.queued_slot = -1;
				return;
			}
			if (value.queued_slot < 0)
			{
				value.queued_slot = slot_index;
				flag2 = true;
			}
			action.abilities[slot_index] = true;
			WormPlayer component2 = ((Component)worm).GetComponent<WormPlayer>();
			if ((Object)(object)component2 != (Object)null)
			{
				AimCam3D(component2, target_delta);
			}
			if (flag2)
			{
				Plugin.log.LogInfo((object)($"[worm] queued lost-sight ability slot={slot_index + 1} " + "type=" + ((object)ability).GetType().Name));
			}
		}

		private static void ConsumeLostSightAbility(WormMovement worm, int slot_index)
		{
			if (lost_sight_abilities.TryGetValue(worm, out var value) && value.queued_slot == slot_index)
			{
				value.queued_slot = -1;
				value.pending = false;
			}
		}

		private static bool IsQueuedLostSightAbility(WormMovement worm, int slot_index)
		{
			if (lost_sight_abilities.TryGetValue(worm, out var value))
			{
				return value.queued_slot == slot_index;
			}
			return false;
		}

		private static void RequeueLostSightAbility(WormMovement worm, int slot_index)
		{
			if (lost_sight_abilities.TryGetValue(worm, out var value) && value.queued_slot == slot_index)
			{
				value.queued_slot = -1;
				value.pending = true;
			}
		}

		private static bool TryFindLostSightAbility(WormMovement worm, WormAbilityManager manager, string movement_state, out int slot_index, out WormAbility ability)
		{
			slot_index = -1;
			ability = null;
			if ((Object)(object)manager == (Object)null)
			{
				return false;
			}
			int num = int.MaxValue;
			for (int i = 0; i < 4; i++)
			{
				WormAbility val = AbilityInSlot(manager, i);
				if (!((Object)(object)val == (Object)null) && val.canUseAbility)
				{
					int num2 = ((!(val is WormAbility_Scream)) ? ((val is WormAbility_SandStorm) ? 1 : ((val is WormAbility_BileBomb) ? 2 : int.MaxValue)) : 0);
					if (num2 < num && CanUseLostSightAbility(worm, val, movement_state))
					{
						num = num2;
						slot_index = i;
						ability = val;
					}
				}
			}
			return (Object)(object)ability != (Object)null;
		}

		private static bool CanUseLostSightAbility(WormMovement worm, WormAbility ability, string movement_state)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Invalid comparison between Unknown and I4
			bool flag = movement_state == "Surface";
			WormPlayer component = ((Component)worm).GetComponent<WormPlayer>();
			try
			{
				if ((Object)(object)component != (Object)null)
				{
					flag = component.aboveGround.Value;
				}
			}
			catch
			{
			}
			if (ability is WormAbility_Scream)
			{
				return flag;
			}
			if (ability is WormAbility_BileBomb)
			{
				WormMouth component2 = ((Component)worm).GetComponent<WormMouth>();
				bool flag2 = (Object)(object)component2 == (Object)null || (int)component2.thingInMouthType.Value == 0;
				return flag && flag2;
			}
			return ability is WormAbility_SandStorm;
		}

		private static WormAbility AbilityInSlot(WormAbilityManager manager, int slot_index)
		{
			if ((Object)(object)manager == (Object)null || slot_index < 0 || slot_index >= 4)
			{
				return null;
			}
			try
			{
				return Traverse.Create((object)manager).Field($"abilitySlot{slot_index + 1}").GetValue<WormAbility>();
			}
			catch
			{
				return null;
			}
		}

		private static void SetDiveIntent(WormMovement worm, Player target)
		{
			DiveIntent value;
			bool flag = committed_attack_runs.TryGetValue(worm, out value) && (Object)(object)value.target == (Object)(object)target && value.lob;
			dive_intents[worm] = new DiveIntent
			{
				target = target,
				created_at = Time.time,
				lob = flag,
				lob_apex_height_scale = (flag ? value.lob_apex_height_scale : 0f)
			};
		}

		private static bool BeginCommittedAttackRun(WormMovement worm, Player target, bool lob = false, float lob_apex_height_scale = 0f)
		{
			if (committed_attack_runs.TryGetValue(worm, out var value) && (Object)(object)value.target == (Object)(object)target && Time.time - value.created_at < 3f)
			{
				return true;
			}
			float value2;
			float num = (attack_run_retry_at.TryGetValue(worm, out value2) ? value2 : 0f);
			if (Time.time < num)
			{
				return false;
			}
			attack_run_retry_at.Remove(worm);
			committed_attack_runs[worm] = new DiveIntent
			{
				target = target,
				created_at = Time.time,
				lob = lob,
				lob_apex_height_scale = (lob ? lob_apex_height_scale : 0f)
			};
			return true;
		}

		private static void LogDiveGate(WormMovement worm, string reason)
		{
			float value;
			float num = (next_dive_gate_log.TryGetValue(worm, out value) ? value : 0f);
			if (!(Time.time < num))
			{
				next_dive_gate_log[worm] = Time.time + 1f;
				Plugin.log.LogInfo((object)("[worm] dive gate=" + reason));
			}
		}

		private static bool TryPlanarDirection(Vector3 value, out Vector3 direction)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			direction = new Vector3(value.x, 0f, value.z);
			if (((Vector3)(ref direction)).sqrMagnitude < 0.0001f)
			{
				direction = Vector3.zero;
				return false;
			}
			((Vector3)(ref direction)).Normalize();
			return true;
		}

		private static Vector3 GetBodyForward(WormMovement worm)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			WormCamLook componentInChildren = ((Component)worm).GetComponentInChildren<WormCamLook>(true);
			if (!((Object)(object)componentInChildren != (Object)null) || !((Object)(object)componentInChildren.wormBody != (Object)null))
			{
				return ((Component)worm).transform.forward;
			}
			return componentInChildren.wormBody.forward;
		}

		private static void ResetMoveControllerDamping(WormMovement worm)
		{
			if (move_controllers.TryGetValue(worm, out var value))
			{
				value.turn_velocity = 0f;
				value.magnitude_velocity = 0f;
			}
		}

		private static void StopMoveController(WormMovement worm)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (move_controllers.TryGetValue(worm, out var value))
			{
				value.turn_velocity = 0f;
				value.magnitude = 0f;
				value.magnitude_velocity = 0f;
				value.output = Vector3.zero;
			}
		}

		private static Player NearestPardner(Vector3 from, out float dist)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			Player val = null;
			float num = float.MaxValue;
			Player[] array = Pardners();
			foreach (Player val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null) && IsAlive(val2))
				{
					Vector3 val3 = ((Component)val2).transform.position - from;
					float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
						val = val2;
					}
				}
			}
			dist = (((Object)(object)val != (Object)null) ? Mathf.Sqrt(num) : float.MaxValue);
			return val;
		}

		public static bool IsAlive(Player p)
		{
			try
			{
				return Traverse.Create((object)p).Field("isAlive").GetValue<bool>();
			}
			catch
			{
				return true;
			}
		}

		private static float DifficultyMultiplier(WormMovement worm)
		{
			return AiWormDifficultyRules.Multiplier((Component)(object)worm);
		}

		private static float MinimumLobApexHeightScale(WormMovement worm)
		{
			if (AiWormDifficultyRules.For((Component)(object)worm) != AiWormDifficulty.Bull)
			{
				return 1.25f;
			}
			return 1f;
		}

		private static float SafeFloat(Traverse t, string field, float fallback)
		{
			try
			{
				return t.Field(field).GetValue<float>();
			}
			catch
			{
				return fallback;
			}
		}

		private static bool SafeBool(Traverse t, string field, bool fallback)
		{
			try
			{
				return t.Field(field).GetValue<bool>();
			}
			catch
			{
				return fallback;
			}
		}

		private static string SafeState(WormMovement worm)
		{
			try
			{
				return Traverse.Create((object)((Component)worm).GetComponent<WormPlayer>()).Field("wormMovementState").GetValue()
					.ToString();
			}
			catch
			{
				return "Surface";
			}
		}
	}
	public static class WormPerception
	{
		private class P
		{
			public float last_visible = -1000f;

			public Vector3 last_known;

			public Vector3 offset_dir = Vector3.forward;

			public Vector3 vel;

			public Vector3 sample_pos;

			public float sample_time = -1f;
		}

		private class FocusState
		{
			public Player target;

			public float remaining = 80f;

			public readonly Dictionary<Player, float> abandoned_until = new Dictionary<Player, float>();
		}

		private class WormState
		{
			public readonly Dictionary<Player, P> players = new Dictionary<Player, P>();

			public readonly FocusState focus = new FocusState();

			public readonly List<Vector3> other_worm_positions = new List<Vector3>();

			public Player current_target;

			public bool blinded_now;

			public int other_worm_frame = -1;
		}

		private const float EXACT_WINDOW = 3f;

		private const float FUZZY_END = 20f;

		private const float OFFSET_MAX = 8f;

		private const float BLIND_OFFSET = 20f;

		private const float CHASE_STICKY = 30f;

		private const float FOCUS_PATIENCE = 80f;

		private const float FOCUS_DRAIN_REVEALED = 2f;

		private const float FOCUS_DRAIN_HIDDEN = 1f;

		private const float ABANDON_COOLDOWN = 80f;

		private const float OTHER_WORM_TARGET_RADIUS = 30f;

		private static readonly Dictionary<WormMovement, WormState> worm_states = new Dictionary<WormMovement, WormState>();

		private static WormState GetState(WormMovement worm)
		{
			if (!worm_states.TryGetValue(worm, out var value))
			{
				value = new WormState();
				worm_states[worm] = value;
			}
			return value;
		}

		private static bool IsAbandoned(FocusState f, Player p)
		{
			if (f.abandoned_until.TryGetValue(p, out var value))
			{
				return Time.time < value;
			}
			return false;
		}

		private static List<Vector3> GetOtherWormPositions(WormMovement worm, WormState state)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (state.other_worm_frame == Time.frameCount)
			{
				return state.other_worm_positions;
			}
			state.other_worm_frame = Time.frameCount;
			state.other_worm_positions.Clear();
			GameManager singleton = GameManager.Singleton;
			if ((Object)(object)worm == (Object)null || (Object)(object)singleton == (Object)null || singleton.wormPlayerScripts == null)
			{
				return state.other_worm_positions;
			}
			foreach (WormPlayer wormPlayerScript in singleton.wormPlayerScripts)
			{
				if (!((Object)(object)wormPlayerScript == (Object)null))
				{
					WormMovement component = ((Component)wormPlayerScript).GetComponent<WormMovement>();
					if (!((Object)(object)component == (Object)null) && !((Object)(object)component == (Object)(object)worm))
					{
						state.other_worm_positions.Add(((Component)component).transform.position);
					}
				}
			}
			return state.other_worm_positions;
		}

		private static bool IsNearOtherWorm(Vector3 perceived_target_position, List<Vector3> other_worm_positions)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			foreach (Vector3 other_worm_position in other_worm_positions)
			{
				Vector3 val = other_worm_position - perceived_target_position;
				val.y = 0f;
				if (((Vector3)(ref val)).sqrMagnitude <= 900f)
				{
					return true;
				}
			}
			return false;
		}

		private static P Get(WormState state, Player p)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (!state.players.TryGetValue(p, out var value))
			{
				value = new P
				{
					offset_dir = RandomDir(),
					last_known = ((Component)p).transform.position
				};
				state.players[p] = value;
			}
			return value;
		}

		private static Vector3 RandomDir()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Random.insideUnitSphere;
		}

		private static bool VisibleNow(Player p)
		{
			try
			{
				return p.isVisibleToWorm_Synced.Value;
			}
			catch
			{
				return false;
			}
		}

		public static bool IsVisible(Player target)
		{
			if ((Object)(object)target != (Object)null)
			{
				return VisibleNow(target);
			}
			return false;
		}

		private static bool IsAlive(Player p)
		{
			try
			{
				return Traverse.Create((object)p).Field("isAlive").GetValue<bool>();
			}
			catch
			{
				return true;
			}
		}

		public static void Tick(WormMovement worm, IEnumerable<Player> pardners)
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			WormState state = GetState(worm);
			try
			{
				WormPlayer component = ((Component)worm).GetComponent<WormPlayer>();
				state.blinded_now = (Object)(object)component != (Object)null && component.isBlinded.Value;
			}
			catch
			{
				state.blinded_now = false;
			}
			foreach (Player pardner in pardners)
			{
				if ((Object)(object)pardner == (Object)null)
				{
					continue;
				}
				P p = Get(state, pardner);
				if (VisibleNow(pardner))
				{
					if (p.sample_time > 0f)
					{
						float num = Time.time - p.sample_time;
						if (num > 0.01f)
						{
							p.vel = (((Component)pardner).transform.position - p.sample_pos) / num;
						}
					}
					p.sample_pos = ((Component)pardner).transform.position;
					p.sample_time = Time.time;
					p.last_visible = Time.time;
					p.last_known = ((Component)pardner).transform.position;
				}
				else if (Time.time - p.last_visible < 20f)
				{
					p.last_known = ((Component)pardner).transform.position;
				}
			}
			DrainFocusPatience(state);
		}

		private static void DrainFocusPatience(WormState state)
		{
			Player current_target = state.current_target;
			FocusState focus = state.focus;
			if ((Object)(object)current_target != (Object)(object)focus.target)
			{
				focus.target = current_target;
				focus.remaining = 80f;
			}
			if (!((Object)(object)current_target == (Object)null) && IsAlive(current_target))
			{
				float num = (VisibleNow(current_target) ? 2f : 1f);
				focus.remaining -= Time.fixedDeltaTime * num;
				if (focus.remaining <= 0f)
				{
					focus.abandoned_until[current_target] = Time.time + 80f;
					focus.remaining = 80f;
					focus.target = null;
					state.current_target = null;
					Plugin.log.LogInfo((object)"[worm] target stalled out our patience; switching to another pardner");
				}
			}
		}

		public static void OnTargetGrabbed(WormMovement worm, Player target)
		{
			if (!((Object)(object)worm == (Object)null) && !((Object)(object)target == (Object)null) && worm_states.TryGetValue(worm, out var value))
			{
				FocusState focus = value.focus;
				focus.abandoned_until.Remove(target);
				if ((Object)(object)focus.target == (Object)(object)target)
				{
					focus.remaining = 80f;
				}
			}
		}

		public static Vector3 PerceivedPosition(WormMovement worm, Player target)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return Vector3.zero;
			}
			WormState state = GetState(worm);
			P p = Get(state, target);
			float num = Time.time - p.last_visible;
			if (state.blinded_now)
			{
				return ((Component)target).transform.position + p.offset_dir * 20f;
			}
			if (VisibleNow(target) || num < 3f)
			{
				return ((Component)target).transform.position;
			}
			if (num < 20f)
			{
				float num2 = 8f * Mathf.Clamp01((num - 3f) / 17f);
				return ((Component)target).transform.position + p.offset_dir * num2;
			}
			return p.last_known + p.offset_dir * 8f;
		}

		public static Vector3 PerceivedVelocity(WormMovement worm, Player target)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return Vector3.zero;
			}
			WormState state = GetState(worm);
			P p = Get(state, target);
			if (state.blinded_now)
			{
				return Vector3.zero;
			}
			if (VisibleNow(target) || Time.time - p.last_visible < 3f)
			{
				return p.vel;
			}
			return Vector3.zero;
		}

		public static float TimeSinceSeen(WormMovement worm, Player target)
		{
			if (!((Object)(object)target == (Object)null))
			{
				return Time.time - Get(GetState(worm), target).last_visible;
			}
			return 9999f;
		}

		public static void OnDiveEnded(WormMovement worm)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (worm_states.TryGetValue(worm, out var value) && (Object)(object)value.current_target != (Object)null)
			{
				Get(value, value.current_target).offset_dir = RandomDir();
			}
		}

		public static Player SelectTarget(WormMovement worm, IEnumerable<Player> pardners)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			WormState state = GetState(worm);
			FocusState focus = state.focus;
			Player val = state.current_target;
			List<Vector3> otherWormPositions = GetOtherWormPositions(worm, state);
			if ((Object)(object)val != (Object)null && IsAlive(val) && !IsAbandoned(focus, val) && Time.time - Get(state, val).last_visible < 30f && !IsNearOtherWorm(PerceivedPosition(worm, val), otherWormPositions))
			{
				return val;
			}
			Player val2 = PickMostRecentlyVisible(pardners, worm, state, focus, skip_abandoned: true, skip_near_other_worm: true, otherWormPositions);
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = PickMostRecentlyVisible(pardners, worm, state, focus, skip_abandoned: true, skip_near_other_worm: false, otherWormPositions);
			}
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = PickMostRecentlyVisible(pardners, worm, state, focus, skip_abandoned: false, skip_near_other_worm: true, otherWormPositions);
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = PickMostRecentlyVisible(pardners, worm, state, focus, skip_abandoned: false, skip_near_other_worm: false, otherWormPositions);
				}
				if ((Object)(object)val2 != (Object)null)
				{
					focus.abandoned_until.Remove(val2);
				}
			}
			if ((Object)(object)val2 != (Object)null)
			{
				val = val2;
			}
			else if ((Object)(object)val != (Object)null && !IsAlive(val))
			{
				val = null;
			}
			state.current_target = val;
			return val;
		}

		private static Player PickMostRecentlyVisible(IEnumerable<Player> pardners, WormMovement worm, WormState state, FocusState fs, bool skip_abandoned, bool skip_near_other_worm, List<Vector3> other_worm_positions)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			Player result = null;
			float num = float.NegativeInfinity;
			foreach (Player pardner in pardners)
			{
				if (!((Object)(object)pardner == (Object)null) && IsAlive(pardner) && (!skip_abandoned || !IsAbandoned(fs, pardner)) && (!skip_near_other_worm || !IsNearOtherWorm(PerceivedPosition(worm, pardner), other_worm_positions)))
				{
					float last_visible = Get(state, pardner).last_visible;
					if (last_visible > num)
					{
						num = last_visible;
						result = pardner;
					}
				}
			}
			return result;
		}

		public static void Remove(WormMovement worm)
		{
			if ((Object)(object)worm != (Object)null)
			{
				worm_states.Remove(worm);
			}
		}

		public static void Reset()
		{
			worm_states.Clear();
		}
	}
	[HarmonyPatch]
	public static class WormPlayerPatches
	{
		private struct VoiceDictionaryState
		{
			public Dictionary<ulong, NfgoPlayer> dictionary;

			public ulong owner_id;

			public bool had_original;

			public NfgoPlayer original;
		}

		private static Camera cap_cam;

		private static GameObject cap_local_obj;

		private static WormPlayer cap_local_worm;

		private static Transform cap_local_worm_t;

		private static PlayerType cap_type;

		private static bool captured;

		[HarmonyPatch(typeof(WormCamLook), "Update")]
		[HarmonyPrefix]
		public static bool WormCamLook_Update_Prefix(WormCamLook __instance)
		{
			return !AiWormManager.IsAiWorm((Component)(object)__instance);
		}

		[HarmonyPatch(typeof(WormPlayer), "OnNetworkSpawn")]
		[HarmonyPrefix]
		private static void OnNetworkSpawn_Prefix(WormPlayer __instance, ref VoiceDictionaryState __state)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			captured = false;
			__state = default(VoiceDictionaryState);
			if (!AiWormManager.IsAiWorm((Component)(object)__instance) || (Object)(object)GameManager.Singleton == (Object)null)
			{
				return;
			}
			try
			{
				GameManager singleton = GameManager.Singleton;
				cap_cam = singleton.activeCamera;
				cap_local_obj = singleton.localPlayerObject;
				cap_local_worm = singleton.localWormScript;
				cap_type = singleton.playerType;
				cap_local_worm_t = (((Object)(object)GroundDetectableManager.Singleton != (Object)null) ? GroundDetectableManager.Singleton.localWormTransform : null);
				captured = true;
				CaptureVoiceEntry(__instance, ref __state);
			}
			catch
			{
			}
		}

		[HarmonyPatch(typeof(WormPlayer), "OnNetworkSpawn")]
		[HarmonyFinalizer]
		private static Exception OnNetworkSpawn_Finalizer(Exception __exception, WormPlayer __instance, VoiceDictionaryState __state)
		{
			bool flag = AiWormManager.IsAiWorm((Component)(object)__instance);
			RestoreVoiceEntry(__state);
			if (flag && captured)
			{
				RestoreHostView(__instance);
			}
			if (__exception != null && flag)
			{
				Plugin.log.LogWarning((object)("suppressed ai-worm OnNetworkSpawn exception: " + __exception.Message));
				return null;
			}
			return __exception;
		}

		[HarmonyPatch(typeof(WormPlayer), "OnNetworkDespawn")]
		[HarmonyPrefix]
		private static void OnNetworkDespawn_Prefix(WormPlayer __instance, ref VoiceDictionaryState __state)
		{
			__state = default(VoiceDictionaryState);
			if ((Object)(object)__instance != (Object)null && (Object)(object)((Component)__instance).GetComponentInParent<AiWorm>() != (Object)null)
			{
				CaptureVoiceEntry(__instance, ref __state);
			}
		}

		[HarmonyPatch(typeof(WormPlayer), "OnNetworkDespawn")]
		[HarmonyFinalizer]
		private static Exception OnNetworkDespawn_Finalizer(Exception __exception, WormPlayer __instance, VoiceDictionaryState __state)
		{
			RestoreVoiceEntry(__state);
			if (__exception != null && (Object)(object)__instance != (Object)null && (Object)(object)((Component)__instance).GetComponentInParent<AiWorm>() != (Object)null)
			{
				Plugin.log.LogWarning((object)("suppressed ai-worm OnNetworkDespawn exception: " + __exception.Message));
				return null;
			}
			return __exception;
		}

		private static void CaptureVoiceEntry(WormPlayer worm, ref VoiceDictionaryState state)
		{
			VoiceChatManager singleton = VoiceChatManager.Singleton;
			if (!((Object)(object)singleton == (Object)null) && singleton.nfgoPlayersDictionary != null)
			{
				state.dictionary = singleton.nfgoPlayersDictionary;
				state.owner_id = ((NetworkBehaviour)worm).OwnerClientId;
				state.had_original = state.dictionary.TryGetValue(state.owner_id, out state.original);
				state.dictionary.Remove(state.owner_id);
			}
		}

		private static void RestoreVoiceEntry(VoiceDictionaryState state)
		{
			if (state.dictionary != null)
			{
				if (state.had_original)
				{
					state.dictionary[state.owner_id] = state.original;
				}
				else
				{
					state.dictionary.Remove(state.owner_id);
				}
			}
		}

		private static void RestoreHostView(WormPlayer worm)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameManager singleton = GameManager.Singleton;
				singleton.playerType = cap_type;
				singleton.localPlayerObject = cap_local_obj;
				singleton.localWormScript = cap_local_worm;
				singleton.activeCamera = cap_cam;
				if ((Object)(object)GroundDetectableManager.Singleton != (Object)null)
				{
					GroundDetectableManager.Singleton.localWormTransform = cap_local_worm_t;
				}
				if ((Object)(object)worm.wormCam != (Object)null)
				{
					((Behaviour)worm.wormCam).enabled = false;
				}
				MeshRenderer[] value = Traverse.Create((object)worm).Field("ourBodySegmentRenderers").GetValue<MeshRenderer[]>();
				if (value != null)
				{
					MeshRenderer[] array = value;
					foreach (MeshRenderer val in array)
					{
						if (!((Object)(object)val == (Object)null))
						{
							((Renderer)val).enabled = true;
							((Renderer)val).shadowCastingMode = (ShadowCastingMode)1;
						}
					}
				}
				Traverse.Create((object)worm).Field("depthOfField_GlobalPostProc").SetValue((object)null);
				Traverse.Create((object)worm).Field("colorAdjustments_GlobalPostProc").SetValue((object)null);
				if ((Object)(object)cap_cam != (Object)null)
				{
					((Behaviour)cap_cam).enabled = true;
					((Component)cap_cam).gameObject.SetActive(true);
				}
				Traverse obj = Traverse.Create((object)HudManager.Singleton);
				obj.Method("ShowHumanPlayerHudGroup", Array.Empty<object>()).GetValue();
				obj.Method("ShowHumanSprintBar", Array.Empty<object>()).GetValue();
				obj.Method("HideWormPlayerHudGroup", Array.Empty<object>()).GetValue();
			}
			catch (Exception ex)
			{
				Plugin.log.LogWarning((object)("restore host view failed: " + ex.Message));
			}
		}
	}
}