using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
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 System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using DM;
using HarmonyLib;
using InControl;
using Landfall.TABS;
using Landfall.TABS.AI.Components;
using Landfall.TABS.AI.Components.Modifiers;
using Landfall.TABS.AI.Components.Tags;
using Landfall.TABS.AI.Systems;
using Landfall.TABS.GameMode;
using Landfall.TABS.GameState;
using Landfall.TABS.TeamEdge;
using Landfall.TABS.UI;
using Landfall.TABS.UI.UIGroups.Attributes;
using Landfall.TABS.UI.Widgets.Fields;
using Landfall.TABS.UI.Widgets.List;
using Landfall.TABS.UI.WinConditions;
using Landfall.TABS.UnitEditor;
using Landfall.TABS.WinConditions;
using Landfall.TABS.Workshop;
using Landfall.TABS_Input;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using StayCombatFix;
using TFBGames;
using TabsUnlimited.CustomVoices;
using TabsUnlimited.TeamLine;
using TabsUnlimited.WinConditions;
using Unity.Entities;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 TabsUnlimited
{
	internal static class BattleStateHelper
	{
		private static int _checkFrame = -1;

		private static bool _cachedBattleActive;

		internal static bool IsBattleActive()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			if (Time.frameCount == _checkFrame)
			{
				return _cachedBattleActive;
			}
			_checkFrame = Time.frameCount;
			GameStateManager service = ServiceLocator.GetService<GameStateManager>();
			_cachedBattleActive = service != null && (int)service.GameState == 1;
			return _cachedBattleActive;
		}

		internal static void InvalidateCache()
		{
			_checkFrame = -1;
		}
	}
	internal enum CustomEnemyTargetingMode
	{
		MostExpensive,
		LowestHealth,
		RangedMixedOnly
	}
	internal static class CustomEnemyTargetingSystem
	{
		private struct TeamEnemySnapshot
		{
			internal Entity Entity;

			internal Unit Unit;

			internal Vector3 Position;

			internal float Cost;

			internal float CurrentHealth;

			internal bool? IsRanged;

			internal float TargetPriority;

			internal float BeingTargetedBy;
		}

		private struct HunterState
		{
			internal Unit Unit;

			internal Entity Entity;

			internal Team Team;

			internal float AttackRange;

			internal Vector3 Position;

			internal CustomEnemyTargetingMode Mode;
		}

		private struct RangeScanResult
		{
			internal bool AnyInNear;

			internal bool AnyInApproach;

			internal bool FoundCurrentTarget;

			internal bool CurrentTargetAlive;

			internal float CurrentTargetSqrDistance;
		}

		private const float MinTargetPriority = 0.1f;

		private const float OvercrowdingFactor = 0.05f;

		private const int InitialSnapshotCapacity = 128;

		private const int InitialHunterCapacity = 32;

		private const int MaxCustomTargetingRetargetsPerFrame = 32;

		private static readonly List<TeamEnemySnapshot>[] TeamSnapshots = new List<TeamEnemySnapshot>[2]
		{
			new List<TeamEnemySnapshot>(128),
			new List<TeamEnemySnapshot>(128)
		};

		private static readonly List<HunterState> Hunters = new List<HunterState>(32);

		private static readonly Dictionary<Entity, float> LastRetargetTime = new Dictionary<Entity, float>();

		private static readonly Dictionary<Entity, TeamEnemySnapshot> SnapshotLookupByEntity = new Dictionary<Entity, TeamEnemySnapshot>();

		private static readonly Dictionary<UnitBlueprint, float> BlueprintCostCache = new Dictionary<UnitBlueprint, float>();

		private static float _lastSnapshotTime = -1f;

		private static int _lastSnapshotUnitCount = -1;

		private static int _retargetBudgetFrame = -1;

		private static int _retargetBudgetRemaining;

		private static readonly HashSet<Entity> IdleCustomHunterEntities = new HashSet<Entity>();

		private static readonly Dictionary<Entity, Unit> IdleCustomHunterUnits = new Dictionary<Entity, Unit>();

		internal static void InvalidateCaches()
		{
			_lastSnapshotTime = -1f;
			_lastSnapshotUnitCount = -1;
			TeamSnapshots[0].Clear();
			TeamSnapshots[1].Clear();
			SnapshotLookupByEntity.Clear();
			Hunters.Clear();
			LastRetargetTime.Clear();
			BlueprintCostCache.Clear();
			IdleCustomHunterEntities.Clear();
			IdleCustomHunterUnits.Clear();
			UnitBlueprintCombatHelper.InvalidateRangedCache();
		}

		internal static void PreUpdateBarrier_OnUpdate_Postfix()
		{
			//IL_00fe: 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_010a: Expected I4, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: 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_00db: 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_016a: 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_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)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: 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_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: 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_0227: 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_024c: 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_0237: Unknown result type (might be due to invalid IL or missing references)
			if (!UnitEditorConfig.CustomTargetingTypesEnabled || !BattleStateHelper.IsBattleActive() || !EcsComponentHelper.IsAvailable)
			{
				return;
			}
			TeamSystem existingManager = EcsComponentHelper.GetExistingManager<TeamSystem>();
			if (existingManager == null)
			{
				return;
			}
			List<Unit> allUnits = existingManager.GetAllUnits();
			if (allUnits == null || allUnits.Count == 0)
			{
				return;
			}
			EntityManager entityManager = null;
			Entity entity;
			for (int i = 0; i < allUnits.Count && !EcsComponentHelper.TryGetEntityManager((Component)(object)allUnits[i], out entity, out entityManager); i++)
			{
			}
			if (!entityManager.IsCreated)
			{
				return;
			}
			IdleCustomHunterEntities.Clear();
			IdleCustomHunterUnits.Clear();
			CollectHunters(allUnits, entityManager);
			if (Hunters.Count == 0)
			{
				return;
			}
			EnsureSnapshotsFresh(existingManager, entityManager, allUnits.Count);
			float time = Time.time;
			float retargetInterval = 0.25f;
			EnsureRetargetBudget();
			for (int j = 0; j < Hunters.Count; j++)
			{
				HunterState hunter = Hunters[j];
				if (FleeDistanceInterop.IsAiEnabled && entityManager.HasComponent<FleeDistance>(hunter.Entity) && (FleeDistanceInterop.IsFleeManaged(hunter.Entity) || FleeDistanceInterop.ShouldFlee(entityManager, hunter.Entity)))
				{
					continue;
				}
				int num = (int)TeamUtlity.GetOtherTeam(hunter.Team);
				List<TeamEnemySnapshot> list = TeamSnapshots[num];
				if (list.Count == 0)
				{
					ForceIdleCustomHunter(entityManager, hunter);
					continue;
				}
				float inRangeCutoffSq = ComputeInRangeCutoffSq(hunter);
				float farMaxSq = ComputeFarMaxSq(hunter);
				Entity val = Entity.Null;
				if (EcsComponentHelper.TryGetComponentData<HasTargetTag>(entityManager, hunter.Entity, out HasTargetTag data))
				{
					val = data.Target;
				}
				RangeScanResult rangeScan = ScanEnemyRanges(list, hunter.Position, inRangeCutoffSq, farMaxSq, val);
				if (!rangeScan.AnyInNear && !rangeScan.AnyInApproach)
				{
					ForceIdleCustomHunter(entityManager, hunter);
					LastRetargetTime[hunter.Entity] = time;
				}
				else
				{
					if (ShouldSkipRetarget(hunter.Entity, val, rangeScan, inRangeCutoffSq, farMaxSq, time, retargetInterval))
					{
						continue;
					}
					bool flag = IsUrgentRetarget(val, rangeScan, inRangeCutoffSq, farMaxSq);
					if (!flag && _retargetBudgetRemaining <= 0)
					{
						continue;
					}
					if (!TryPickTargetSinglePass(hunter.Mode, hunter.Position, hunter.AttackRange, inRangeCutoffSq, farMaxSq, list, rangeScan.AnyInNear, out var targetEntity, out var usedNearMode))
					{
						ForceIdleCustomHunter(entityManager, hunter);
						continue;
					}
					if (!flag)
					{
						_retargetBudgetRemaining--;
					}
					if (targetEntity == val)
					{
						LastRetargetTime[hunter.Entity] = time;
						continue;
					}
					ApplyTarget(entityManager, hunter.Entity, targetEntity, usedNearMode);
					LastRetargetTime[hunter.Entity] = time;
				}
			}
		}

		internal static void UnitECSToMonoSyncSystem_OnUpdate_Postfix()
		{
			if (!UnitEditorConfig.CustomTargetingTypesEnabled || !BattleStateHelper.IsBattleActive() || IdleCustomHunterUnits.Count == 0)
			{
				return;
			}
			foreach (KeyValuePair<Entity, Unit> idleCustomHunterUnit in IdleCustomHunterUnits)
			{
				Unit value = idleCustomHunterUnit.Value;
				if (!((Object)(object)value == (Object)null) && !value.dead && !((Object)(object)value.api == (Object)null))
				{
					value.api.SetMovementSpeed(0f, true);
				}
			}
		}

		private static float ComputeInRangeCutoffSq(HunterState hunter)
		{
			float item = GetRangeProfile(hunter.Mode, hunter.AttackRange).nearFraction;
			float num = hunter.AttackRange * item;
			return num * num;
		}

		private static float ComputeFarMaxSq(HunterState hunter)
		{
			float item = GetRangeProfile(hunter.Mode, hunter.AttackRange).approachMultiplier;
			float num = hunter.AttackRange * item;
			return num * num;
		}

		private static RangeScanResult ScanEnemyRanges(List<TeamEnemySnapshot> enemies, Vector3 hunterPosition, float inRangeCutoffSq, float farMaxSq, Entity currentTarget)
		{
			//IL_0016: 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_0029: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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)
			RangeScanResult rangeScanResult = default(RangeScanResult);
			rangeScanResult.CurrentTargetSqrDistance = float.MaxValue;
			RangeScanResult result = rangeScanResult;
			Vector3 val;
			if (currentTarget != Entity.Null && SnapshotLookupByEntity.TryGetValue(currentTarget, out var value))
			{
				result.FoundCurrentTarget = true;
				result.CurrentTargetAlive = (Object)(object)value.Unit != (Object)null && !value.Unit.dead;
				val = value.Position - hunterPosition;
				result.CurrentTargetSqrDistance = ((Vector3)(ref val)).sqrMagnitude;
			}
			for (int i = 0; i < enemies.Count; i++)
			{
				val = enemies[i].Position - hunterPosition;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude <= inRangeCutoffSq)
				{
					result.AnyInNear = true;
				}
				if (sqrMagnitude <= farMaxSq)
				{
					result.AnyInApproach = true;
				}
				if (result.AnyInNear && result.AnyInApproach)
				{
					break;
				}
			}
			return result;
		}

		private static bool ShouldSkipRetarget(Entity hunterEntity, Entity currentTarget, RangeScanResult rangeScan, float inRangeCutoffSq, float farMaxSq, float now, float retargetInterval)
		{
			//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_005e: Unknown result type (might be due to invalid IL or missing references)
			if (currentTarget == Entity.Null)
			{
				return false;
			}
			if (!rangeScan.FoundCurrentTarget || !rangeScan.CurrentTargetAlive)
			{
				return false;
			}
			if (rangeScan.AnyInNear && rangeScan.CurrentTargetSqrDistance > inRangeCutoffSq)
			{
				return false;
			}
			if (!rangeScan.AnyInNear && rangeScan.AnyInApproach && rangeScan.CurrentTargetSqrDistance > farMaxSq)
			{
				return false;
			}
			if (retargetInterval <= 0f || !LastRetargetTime.TryGetValue(hunterEntity, out var value) || now - value >= retargetInterval)
			{
				return false;
			}
			if (!rangeScan.AnyInNear && !rangeScan.AnyInApproach && rangeScan.CurrentTargetSqrDistance <= farMaxSq)
			{
				return false;
			}
			return true;
		}

		private static bool IsUrgentRetarget(Entity currentTarget, RangeScanResult rangeScan, float inRangeCutoffSq, float farMaxSq)
		{
			//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)
			if (currentTarget == Entity.Null)
			{
				return true;
			}
			if (!rangeScan.FoundCurrentTarget || !rangeScan.CurrentTargetAlive)
			{
				return true;
			}
			if (rangeScan.AnyInNear && rangeScan.CurrentTargetSqrDistance > inRangeCutoffSq)
			{
				return true;
			}
			if (!rangeScan.AnyInNear && rangeScan.AnyInApproach && rangeScan.CurrentTargetSqrDistance > farMaxSq)
			{
				return true;
			}
			return false;
		}

		private static void ForceIdleCustomHunter(EntityManager entityManager, HunterState hunter)
		{
			//IL_0002: 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_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_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_0042: 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_0036: 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_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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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)
			entityManager.SetComponentData<HasTargetTag>(hunter.Entity, new HasTargetTag
			{
				Target = Entity.Null
			});
			if (entityManager.HasComponent<TargetData>(hunter.Entity))
			{
				entityManager.SetComponentData<TargetData>(hunter.Entity, TargetData.Null);
			}
			if (entityManager.HasComponent<Velocity>(hunter.Entity))
			{
				entityManager.SetComponentData<Velocity>(hunter.Entity, new Velocity
				{
					Value = float3.zero
				});
			}
			IdleCustomHunterEntities.Add(hunter.Entity);
			if ((Object)(object)hunter.Unit != (Object)null)
			{
				IdleCustomHunterUnits[hunter.Entity] = hunter.Unit;
			}
		}

		private static void EnsureRetargetBudget()
		{
			if (Time.frameCount != _retargetBudgetFrame)
			{
				_retargetBudgetFrame = Time.frameCount;
				_retargetBudgetRemaining = 32;
			}
		}

		private static void EnsureSnapshotsFresh(TeamSystem teamSystem, EntityManager entityManager, int liveUnitCount)
		{
			float time = Time.time;
			float num = 0.25f;
			int num2 = TeamSnapshots[0].Count + TeamSnapshots[1].Count;
			if (!(_lastSnapshotTime >= 0f) || !(time - _lastSnapshotTime < num) || _lastSnapshotUnitCount != liveUnitCount || num2 <= 0)
			{
				BuildTeamSnapshots(teamSystem, entityManager);
				RebuildSnapshotLookup();
				_lastSnapshotTime = time;
				_lastSnapshotUnitCount = liveUnitCount;
			}
		}

		private static void RebuildSnapshotLookup()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			SnapshotLookupByEntity.Clear();
			for (int i = 0; i < TeamSnapshots.Length; i++)
			{
				List<TeamEnemySnapshot> list = TeamSnapshots[i];
				for (int j = 0; j < list.Count; j++)
				{
					SnapshotLookupByEntity[list[j].Entity] = list[j];
				}
			}
		}

		private static void BuildTeamSnapshots(TeamSystem teamSystem, EntityManager entityManager)
		{
			TeamSnapshots[0].Clear();
			TeamSnapshots[1].Clear();
			AddTeamSnapshot(teamSystem, entityManager, (Team)0, TeamSnapshots[0]);
			AddTeamSnapshot(teamSystem, entityManager, (Team)1, TeamSnapshots[1]);
		}

		private static void AddTeamSnapshot(TeamSystem teamSystem, EntityManager entityManager, Team team, List<TeamEnemySnapshot> snapshot)
		{
			//IL_0001: 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_006e: 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_0089: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//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_00c5: 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)
			List<Unit> teamUnits = teamSystem.GetTeamUnits(team);
			if (teamUnits == null)
			{
				return;
			}
			for (int i = 0; i < teamUnits.Count; i++)
			{
				Unit val = teamUnits[i];
				if (!((Object)(object)val == (Object)null) && !val.dead && EcsComponentHelper.TryGetEntityManager((Component)(object)val, out var entity, out var _))
				{
					float targetPriority = 0.1f;
					if (EcsComponentHelper.TryGetComponentData<TargetPriority>(entityManager, entity, out TargetPriority data))
					{
						targetPriority = Mathf.Max(data.Value, 0.1f);
					}
					float beingTargetedBy = 0f;
					if (EcsComponentHelper.TryGetComponentData<BeingTargetedBy>(entityManager, entity, out BeingTargetedBy data2))
					{
						beingTargetedBy = data2.Value;
					}
					float currentHealth = float.MaxValue;
					if (EcsComponentHelper.TryGetComponentData<Health>(entityManager, entity, out Health data3))
					{
						currentHealth = data3.CurrentHealth;
					}
					snapshot.Add(new TeamEnemySnapshot
					{
						Entity = entity,
						Unit = val,
						Position = GetUnitPosition(val),
						Cost = GetUnitCost(entityManager, entity, val),
						CurrentHealth = currentHealth,
						IsRanged = UnitBlueprintCombatHelper.ClassifyIsRanged(val.unitBlueprint),
						TargetPriority = targetPriority,
						BeingTargetedBy = beingTargetedBy
					});
				}
			}
		}

		private static void CollectHunters(List<Unit> allUnits, EntityManager entityManager)
		{
			//IL_003b: 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_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_0073: 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)
			Hunters.Clear();
			if (allUnits == null)
			{
				return;
			}
			for (int i = 0; i < allUnits.Count; i++)
			{
				Unit val = allUnits[i];
				if (!((Object)(object)val == (Object)null) && !val.dead && EcsComponentHelper.TryGetEntityManager((Component)(object)val, out var entity, out var _) && TryGetTargetingMode(entityManager, entity, out var mode))
				{
					Hunters.Add(new HunterState
					{
						Unit = val,
						Entity = entity,
						Team = val.Team,
						AttackRange = GetAttackRange(val, entityManager, entity),
						Position = GetUnitPosition(val),
						Mode = mode
					});
				}
			}
		}

		private static bool TryGetTargetingMode(EntityManager entityManager, Entity entity, out CustomEnemyTargetingMode mode)
		{
			//IL_0001: 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)
			if (entityManager.HasComponent<EnemyHighestPriceTargeting>(entity))
			{
				mode = CustomEnemyTargetingMode.MostExpensive;
				return true;
			}
			if (entityManager.HasComponent<EnemyLowestHealthTargeting>(entity))
			{
				mode = CustomEnemyTargetingMode.LowestHealth;
				return true;
			}
			if (entityManager.HasComponent<EnemyRangedMixedTargeting>(entity))
			{
				mode = CustomEnemyTargetingMode.RangedMixedOnly;
				return true;
			}
			mode = CustomEnemyTargetingMode.MostExpensive;
			return false;
		}

		private static bool TryPickTargetSinglePass(CustomEnemyTargetingMode mode, Vector3 hunterPosition, float attackRange, float inRangeCutoffSq, float farMaxSq, List<TeamEnemySnapshot> enemies, bool anyInNear, out Entity targetEntity, out bool usedNearMode)
		{
			//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_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_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_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_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_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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: 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_0205: 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)
			//IL_01a3: 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_018a: 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_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: 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_01b0: 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_019a: 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_016b: 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_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			targetEntity = Entity.Null;
			usedNearMode = anyInNear;
			Entity val = Entity.Null;
			float num = float.MinValue;
			Entity val2 = Entity.Null;
			float num2 = float.MinValue;
			Entity bestEntity = Entity.Null;
			float bestCost = float.MinValue;
			float bestSqrDistance = float.MaxValue;
			Entity bestEntity2 = Entity.Null;
			float bestHealth = float.MaxValue;
			float bestSqrDistance2 = float.MaxValue;
			Entity val3 = Entity.Null;
			float num3 = float.MaxValue;
			Entity val4 = Entity.Null;
			float num4 = float.MaxValue;
			for (int i = 0; i < enemies.Count; i++)
			{
				TeamEnemySnapshot candidate = enemies[i];
				Vector3 val5 = candidate.Position - hunterPosition;
				float sqrMagnitude = ((Vector3)(ref val5)).sqrMagnitude;
				if (sqrMagnitude <= inRangeCutoffSq)
				{
					float num5 = (0f - Mathf.Sqrt(sqrMagnitude)) / candidate.TargetPriority - candidate.BeingTargetedBy * attackRange * 0.05f;
					if (num5 > num)
					{
						num = num5;
						val = candidate.Entity;
					}
					if (candidate.IsRanged == false && num5 > num2)
					{
						num2 = num5;
						val2 = candidate.Entity;
					}
				}
				if (sqrMagnitude <= farMaxSq)
				{
					ConsiderHighestCost(candidate, sqrMagnitude, ref bestEntity, ref bestCost, ref bestSqrDistance);
					ConsiderLowestHealth(candidate, sqrMagnitude, ref bestEntity2, ref bestHealth, ref bestSqrDistance2);
					if (candidate.IsRanged != false && sqrMagnitude < num3)
					{
						num3 = sqrMagnitude;
						val3 = candidate.Entity;
					}
					if (sqrMagnitude < num4)
					{
						num4 = sqrMagnitude;
						val4 = candidate.Entity;
					}
				}
			}
			if (usedNearMode)
			{
				if (mode == CustomEnemyTargetingMode.RangedMixedOnly && val2 != Entity.Null)
				{
					targetEntity = val2;
				}
				else
				{
					targetEntity = val;
				}
				return targetEntity != Entity.Null;
			}
			switch (mode)
			{
			case CustomEnemyTargetingMode.MostExpensive:
				if (bestEntity != Entity.Null)
				{
					targetEntity = bestEntity;
					return true;
				}
				return false;
			case CustomEnemyTargetingMode.LowestHealth:
				if (bestEntity2 != Entity.Null)
				{
					targetEntity = bestEntity2;
					return true;
				}
				return false;
			case CustomEnemyTargetingMode.RangedMixedOnly:
				if (val3 != Entity.Null)
				{
					targetEntity = val3;
					return true;
				}
				if (val4 != Entity.Null)
				{
					targetEntity = val4;
					return true;
				}
				return false;
			default:
				return false;
			}
		}

		private static void ConsiderHighestCost(TeamEnemySnapshot candidate, float sqrDistance, ref Entity bestEntity, ref float bestCost, ref float bestSqrDistance)
		{
			//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)
			if (!(candidate.Cost < bestCost) && (!Mathf.Approximately(candidate.Cost, bestCost) || !(sqrDistance >= bestSqrDistance)))
			{
				bestCost = candidate.Cost;
				bestSqrDistance = sqrDistance;
				bestEntity = candidate.Entity;
			}
		}

		private static void ConsiderLowestHealth(TeamEnemySnapshot candidate, float sqrDistance, ref Entity bestEntity, ref float bestHealth, ref float bestSqrDistance)
		{
			//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)
			if (!(candidate.CurrentHealth > bestHealth) && (!Mathf.Approximately(candidate.CurrentHealth, bestHealth) || !(sqrDistance >= bestSqrDistance)))
			{
				bestHealth = candidate.CurrentHealth;
				bestSqrDistance = sqrDistance;
				bestEntity = candidate.Entity;
			}
		}

		private static void ApplyTarget(EntityManager entityManager, Entity hunterEntity, Entity targetEntity, bool usedNearMode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: 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_0012: 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_001c: 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_002a: 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_0034: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			entityManager.SetComponentData<HasTargetTag>(hunterEntity, new HasTargetTag
			{
				Target = targetEntity
			});
			entityManager.SetComponentData<IsTarget>(targetEntity, new IsTarget
			{
				Targetee = hunterEntity
			});
			entityManager.SetComponentData<AttackThickness>(hunterEntity, new AttackThickness
			{
				Value = 0f
			});
			if (usedNearMode && EcsComponentHelper.TryGetComponentData<BeingTargetedBy>(entityManager, targetEntity, out BeingTargetedBy data))
			{
				data.Value += 1f;
				entityManager.SetComponentData<BeingTargetedBy>(targetEntity, data);
			}
		}

		private static (float nearFraction, float approachMultiplier) GetRangeProfile(CustomEnemyTargetingMode mode, float attackRange)
		{
			bool flag = attackRange <= 15f;
			if (mode == CustomEnemyTargetingMode.RangedMixedOnly)
			{
				if (!flag)
				{
					return (0.25f, 1.5f);
				}
				return (0.5f, 2.5f);
			}
			if (!flag)
			{
				return (0.5f, 1.5f);
			}
			return (0.75f, 2.5f);
		}

		private static float GetAttackRange(Unit hunter, EntityManager entityManager, Entity hunterEntity)
		{
			//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)
			if (EcsComponentHelper.TryGetComponentData<Range>(entityManager, hunterEntity, out Range data))
			{
				return data.AttackRange;
			}
			if (!((Object)(object)hunter != (Object)null))
			{
				return 1f;
			}
			return hunter.m_AttackDistance;
		}

		private static float GetUnitCost(EntityManager entityManager, Entity entity, Unit unit)
		{
			//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)
			if (EcsComponentHelper.TryGetComponentData<UnitCost>(entityManager, entity, out UnitCost data))
			{
				return data.Value;
			}
			UnitBlueprint val = unit?.unitBlueprint;
			if ((Object)(object)val == (Object)null)
			{
				return 0f;
			}
			if (BlueprintCostCache.TryGetValue(val, out var value))
			{
				return value;
			}
			value = val.GetUnitCost(true);
			BlueprintCostCache[val] = value;
			return value;
		}

		private static Vector3 GetUnitPosition(Unit unit)
		{
			//IL_002b: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)unit?.data?.mainRig != (Object)null)
			{
				return unit.data.mainRig.position;
			}
			if (!((Object)(object)unit != (Object)null))
			{
				return Vector3.zero;
			}
			return ((Component)unit).transform.position;
		}
	}
	internal enum CustomVoiceOverlayView
	{
		Hub,
		OggEditor
	}
	internal static class CustomVoiceEditorOverlay
	{
		private sealed class OggRowUi
		{
			internal string FileName;

			internal Button NormalButton;

			internal Button DeathButton;

			internal Text NormalLabel;

			internal Text DeathLabel;
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Action <0>__UpdateSummary;

			public static UnityAction <1>__ShowHub;

			public static UnityAction <2>__SavePack;

			public static UnityAction <3>__DeleteEditingPack;

			public static UnityAction <4>__ShowOggEditorNew;

			public static UnityAction <5>__Close;

			public static UnityAction <6>__OpenSourcesFolder;
		}

		private const float RowHeight = 48f;

		private const float HubHeaderHeight = 148f;

		private const float EditorHeaderHeight = 200f;

		private const float FooterHeight = 52f;

		private static readonly Color RowEven = new Color(0.11f, 0.11f, 0.11f, 0.92f);

		private static readonly Color RowOdd = new Color(0.145f, 0.145f, 0.145f, 0.92f);

		private static readonly Color ToggleOn = new Color(0.2f, 0.48f, 0.28f, 0.98f);

		private static readonly Color ToggleOff = new Color(0.18f, 0.18f, 0.18f, 0.96f);

		private static GameObject _canvasRoot;

		private static GameObject _panel;

		private static RectTransform _headerRect;

		private static RectTransform _scrollHostRect;

		private static Text _titleText;

		private static Text _instructionsText;

		private static Text _summaryText;

		private static InputField _searchField;

		private static RectTransform _searchRect;

		private static GameObject _packNameContainer;

		private static InputField _packNameField;

		private static Button _openFolderButton;

		private static Transform _listContent;

		private static ScrollRect _scrollRect;

		private static GameObject _footer;

		private static Button _footerPrimary;

		private static Button _footerSecondary;

		private static Button _footerDelete;

		private static Text _footerPrimaryLabel;

		private static Text _footerSecondaryLabel;

		private static CustomVoiceOverlayView _view = CustomVoiceOverlayView.Hub;

		private static string _search = string.Empty;

		private static string _editingPackId;

		private static readonly Dictionary<string, bool> NormalByFile = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, bool> DeathByFile = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

		private static readonly List<OggRowUi> OggRows = new List<OggRowUi>();

		internal static bool IsOpen
		{
			get
			{
				if ((Object)(object)_panel != (Object)null)
				{
					return _panel.activeSelf;
				}
				return false;
			}
		}

		internal static void Open()
		{
			if (UnitEditorConfig.CustomVoicesEnabled)
			{
				CustomVoiceStore.LoadAll();
				EnsureBuilt();
				_search = string.Empty;
				_editingPackId = null;
				if ((Object)(object)_searchField != (Object)null)
				{
					_searchField.text = string.Empty;
				}
				_canvasRoot.SetActive(true);
				_panel.SetActive(true);
				UpdateInstructions();
				UpdateTabTitle();
				ShowHub();
				CustomVoiceOggCatalog.BeginRefresh(UpdateSummary);
			}
		}

		internal static void Close()
		{
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(false);
			}
			if ((Object)(object)_canvasRoot != (Object)null)
			{
				_canvasRoot.SetActive(false);
			}
			_editingPackId = null;
			NormalByFile.Clear();
			DeathByFile.Clear();
		}

		private static void ShowHub()
		{
			_view = CustomVoiceOverlayView.Hub;
			_editingPackId = null;
			NormalByFile.Clear();
			DeathByFile.Clear();
			RefreshUi();
		}

		private static void ShowOggEditorNew()
		{
			_view = CustomVoiceOverlayView.OggEditor;
			_editingPackId = null;
			NormalByFile.Clear();
			DeathByFile.Clear();
			if ((Object)(object)_packNameField != (Object)null)
			{
				_packNameField.text = string.Empty;
			}
			BeginCatalogRefreshForEditor();
		}

		private static void ShowOggEditorForEdit(CustomVoicePack pack)
		{
			if (pack == null)
			{
				return;
			}
			_view = CustomVoiceOverlayView.OggEditor;
			_editingPackId = pack.id;
			NormalByFile.Clear();
			DeathByFile.Clear();
			if (pack.vocalFiles != null)
			{
				for (int i = 0; i < pack.vocalFiles.Count; i++)
				{
					NormalByFile[pack.vocalFiles[i]] = true;
				}
			}
			if (pack.deathFiles != null)
			{
				for (int j = 0; j < pack.deathFiles.Count; j++)
				{
					DeathByFile[pack.deathFiles[j]] = true;
				}
			}
			if ((Object)(object)_packNameField != (Object)null)
			{
				_packNameField.text = pack.name ?? "Custom Voice";
			}
			BeginCatalogRefreshForEditor();
		}

		private static void BeginCatalogRefreshForEditor()
		{
			UpdateHeaderLayout();
			UpdateInstructions();
			ConfigureFooter();
			ClearListRows();
			UpdateSummary();
			CustomVoiceOggCatalog.BeginRefresh(delegate
			{
				PruneIneligibleSelections();
				RefreshUi();
			});
		}

		private static void PruneIneligibleSelections()
		{
			foreach (string item in NormalByFile.Keys.ToList())
			{
				if (!CustomVoiceOggCatalog.IsFileEligible(item))
				{
					NormalByFile[item] = false;
				}
			}
			foreach (string item2 in DeathByFile.Keys.ToList())
			{
				if (!CustomVoiceOggCatalog.IsFileEligible(item2))
				{
					DeathByFile[item2] = false;
				}
			}
		}

		private static void RefreshUi()
		{
			UpdateHeaderLayout();
			UpdateInstructions();
			ConfigureFooter();
			ClearListRows();
			UpdateSummary();
			if (_view == CustomVoiceOverlayView.Hub)
			{
				BuildHubRows();
			}
			else
			{
				BuildOggRows();
			}
			if ((Object)(object)_scrollRect != (Object)null)
			{
				_scrollRect.verticalNormalizedPosition = 1f;
			}
		}

		private static void UpdateHeaderLayout()
		{
			//IL_0031: 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_0144: 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_0176: 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_01a8: 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_00de: 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_0110: 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_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: 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_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: 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_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: 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_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			bool flag = _view == CustomVoiceOverlayView.OggEditor;
			float num = (flag ? 200f : 148f);
			if ((Object)(object)_headerRect != (Object)null)
			{
				_headerRect.sizeDelta = new Vector2(0f, num);
			}
			if ((Object)(object)_scrollHostRect != (Object)null)
			{
				_scrollHostRect.offsetMax = new Vector2(-8f, 0f - (num + 4f));
			}
			if ((Object)(object)_packNameContainer != (Object)null)
			{
				_packNameContainer.SetActive(flag);
			}
			UpdateTabTitle();
			UpdateInstructions();
			if ((Object)(object)_openFolderButton != (Object)null)
			{
				((Component)_openFolderButton).gameObject.SetActive(flag);
			}
			if ((Object)(object)_searchRect != (Object)null)
			{
				if (flag)
				{
					_searchRect.anchorMin = new Vector2(0f, 0f);
					_searchRect.anchorMax = new Vector2(0f, 0f);
					_searchRect.pivot = new Vector2(0f, 0f);
					_searchRect.anchoredPosition = new Vector2(16f, 12f);
					_searchRect.sizeDelta = new Vector2(360f, 32f);
				}
				else
				{
					_searchRect.anchorMin = new Vector2(0f, 0f);
					_searchRect.anchorMax = new Vector2(0f, 0f);
					_searchRect.pivot = new Vector2(0f, 0f);
					_searchRect.anchoredPosition = new Vector2(16f, 12f);
					_searchRect.sizeDelta = new Vector2(360f, 32f);
				}
			}
			if ((Object)(object)_instructionsText != (Object)null)
			{
				RectTransform component = ((Component)_instructionsText).GetComponent<RectTransform>();
				if (flag)
				{
					component.offsetMin = new Vector2(16f, -108f);
					component.offsetMax = new Vector2(-120f, -32f);
				}
				else
				{
					component.offsetMin = new Vector2(16f, -88f);
					component.offsetMax = new Vector2(-16f, -32f);
				}
			}
			if ((Object)(object)_titleText != (Object)null)
			{
				RectTransform component2 = ((Component)_titleText).GetComponent<RectTransform>();
				component2.offsetMin = new Vector2(16f, -8f);
				component2.offsetMax = new Vector2(-120f, -28f);
			}
			if ((Object)(object)_packNameContainer != (Object)null && flag)
			{
				RectTransform component3 = _packNameContainer.GetComponent<RectTransform>();
				component3.anchorMin = new Vector2(0f, 1f);
				component3.anchorMax = new Vector2(0f, 1f);
				component3.pivot = new Vector2(0f, 1f);
				component3.anchoredPosition = new Vector2(16f, -114f);
				component3.sizeDelta = new Vector2(280f, 24f);
			}
			if ((Object)(object)_summaryText != (Object)null)
			{
				RectTransform component4 = ((Component)_summaryText).GetComponent<RectTransform>();
				component4.anchorMin = new Vector2(0f, 0f);
				component4.anchorMax = new Vector2(0f, 0f);
				component4.pivot = new Vector2(0f, 0f);
				component4.anchoredPosition = new Vector2(392f, 12f);
				component4.sizeDelta = new Vector2(flag ? 280f : 360f, 32f);
				_summaryText.alignment = (TextAnchor)3;
				((Component)_summaryText).gameObject.SetActive(true);
			}
		}

		private static void UpdateTabTitle()
		{
			if (!((Object)(object)_titleText == (Object)null))
			{
				if (_view == CustomVoiceOverlayView.Hub)
				{
					_titleText.text = "CUSTOM VOICES";
				}
				else if (!string.IsNullOrEmpty(_editingPackId))
				{
					_titleText.text = "EDIT VOICE";
				}
				else
				{
					_titleText.text = "MAKE NEW VOICE";
				}
			}
		}

		private static void UpdateInstructions()
		{
			if (!((Object)(object)_instructionsText == (Object)null))
			{
				if (_view == CustomVoiceOverlayView.Hub)
				{
					_instructionsText.text = "Make New Voice to create a pack. Equip applies a pack to your unit; Edit changes its sounds. Voice files live in CustomContent/voices — use Open File in the editor to add .ogg files.";
				}
				else
				{
					_instructionsText.text = "Type a name, then assign sounds below. Only .ogg files up to " + 7f.ToString("0.#") + " seconds appear here. Open File opens CustomContent/voices — copy .ogg files there, then press Back and re-enter to refresh. Delete removes a file from disk and all packs. Preview plays a file. Pick at least one Normal and one Death line before Save.";
				}
			}
		}

		private static void ConfigureFooter()
		{
			//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_008a: Expected O, but got Unknown
			//IL_00a4: 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: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			if ((Object)(object)_footer == (Object)null)
			{
				return;
			}
			if (_view == CustomVoiceOverlayView.Hub)
			{
				_footer.SetActive(false);
				return;
			}
			_footer.SetActive(true);
			((Component)_footerSecondary).gameObject.SetActive(true);
			((Component)_footerPrimary).gameObject.SetActive(true);
			_footerSecondaryLabel.text = "Back";
			_footerPrimaryLabel.text = "Save";
			Button footerSecondary = _footerSecondary;
			object obj = <>O.<1>__ShowHub;
			if (obj == null)
			{
				UnityAction val = ShowHub;
				<>O.<1>__ShowHub = val;
				obj = (object)val;
			}
			UnitEditorUiText.ReplaceButtonClick(footerSecondary, (UnityAction)obj);
			Button footerPrimary = _footerPrimary;
			object obj2 = <>O.<2>__SavePack;
			if (obj2 == null)
			{
				UnityAction val2 = SavePack;
				<>O.<2>__SavePack = val2;
				obj2 = (object)val2;
			}
			UnitEditorUiText.ReplaceButtonClick(footerPrimary, (UnityAction)obj2);
			if (!((Object)(object)_footerDelete != (Object)null))
			{
				return;
			}
			bool flag = !string.IsNullOrEmpty(_editingPackId);
			((Component)_footerDelete).gameObject.SetActive(flag);
			if (flag)
			{
				Button footerDelete = _footerDelete;
				object obj3 = <>O.<3>__DeleteEditingPack;
				if (obj3 == null)
				{
					UnityAction val3 = DeleteEditingPack;
					<>O.<3>__DeleteEditingPack = val3;
					obj3 = (object)val3;
				}
				UnitEditorUiText.ReplaceButtonClick(footerDelete, (UnityAction)obj3);
			}
		}

		private static void BuildHubRows()
		{
			if (MatchesSearch("Make New Voice"))
			{
				CreateMakeNewHubRow();
			}
			IReadOnlyList<CustomVoicePack> allPacks = CustomVoiceStore.AllPacks;
			for (int i = 0; i < allPacks.Count; i++)
			{
				CustomVoicePack customVoicePack = allPacks[i];
				if (customVoicePack != null && MatchesSearch(customVoicePack.name))
				{
					CreatePackHubRow(customVoicePack);
				}
			}
		}

		private static void CreateMakeNewHubRow()
		{
			//IL_002b: 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_005e: 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_008f: Expected O, but got Unknown
			GameObject obj = CreateRowShell("MakeNew".GetHashCode());
			Image component = obj.GetComponent<Image>();
			((Graphic)component).color = new Color(0.16f, 0.32f, 0.18f, 0.95f);
			CreateRowLabel(obj.transform, "Make New Voice", 16f, new Vector2(12f, 0f), new Vector2(-12f, 0f));
			Button obj2 = obj.AddComponent<Button>();
			((Selectable)obj2).targetGraphic = (Graphic)(object)component;
			object obj3 = <>O.<4>__ShowOggEditorNew;
			if (obj3 == null)
			{
				UnityAction val = ShowOggEditorNew;
				<>O.<4>__ShowOggEditorNew = val;
				obj3 = (object)val;
			}
			UnitEditorUiText.ReplaceButtonClick(obj2, (UnityAction)obj3);
		}

		private static void CreatePackHubRow(CustomVoicePack pack)
		{
			//IL_001d: 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_0051: 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_00cb: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: 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_0149: Expected O, but got Unknown
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Expected O, but got Unknown
			GameObject val = CreateRowShell(pack.id.GetHashCode());
			((Graphic)val.GetComponent<Image>()).color = RowEven;
			CreateRowLabel(val.transform, pack.name, 16f, new Vector2(56f, 0f), new Vector2(-260f, 0f));
			if (CustomVoiceRegistry.TryGetBundle(pack.id, out var bundle))
			{
				object obj;
				if (bundle == null)
				{
					obj = null;
				}
				else
				{
					DatabaseEntity entity = bundle.Entity;
					obj = ((entity != null) ? entity.SpriteIcon : null);
				}
				if ((Object)obj != (Object)null)
				{
					CreateRowIcon(val.transform, bundle.Entity.SpriteIcon);
				}
			}
			CustomVoicePack captured = pack;
			Button button = CreateSmallButton(val.transform, "Edit", new Vector2(-176f, 0f), new Vector2(72f, 32f), (TextAnchor)5);
			Button button2 = CreateSmallButton(val.transform, "Equip", new Vector2(-96f, 0f), new Vector2(72f, 32f), (TextAnchor)5);
			Button button3 = CreateSmallButton(val.transform, "Delete", new Vector2(-16f, 0f), new Vector2(72f, 32f), (TextAnchor)5);
			UnitEditorUiText.ReplaceButtonClick(button, (UnityAction)delegate
			{
				ShowOggEditorForEdit(captured);
			});
			UnitEditorUiText.ReplaceButtonClick(button2, (UnityAction)delegate
			{
				EquipPack(captured);
			});
			UnitEditorUiText.ReplaceButtonClick(button3, (UnityAction)delegate
			{
				DeletePack(captured);
			});
		}

		private static void BuildOggRows()
		{
			OggRows.Clear();
			IReadOnlyList<CustomVoiceOggEntry> entriesSnapshot = CustomVoiceOggCatalog.EntriesSnapshot;
			for (int i = 0; i < entriesSnapshot.Count; i++)
			{
				CustomVoiceOggEntry customVoiceOggEntry = entriesSnapshot[i];
				if (customVoiceOggEntry != null && (MatchesSearch(customVoiceOggEntry.DisplayName) || MatchesSearch(customVoiceOggEntry.FileName)))
				{
					CreateOggRow(customVoiceOggEntry, i);
				}
			}
			RefreshAllOggToggleStates();
		}

		private static void CreateOggRow(CustomVoiceOggEntry entry, int index)
		{
			//IL_0034: 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_005e: 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_008c: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_00cc: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_013a: 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_0156: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Expected O, but got Unknown
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Expected O, but got Unknown
			GameObject obj = CreateRowShell(entry.FileName.GetHashCode());
			((Graphic)obj.GetComponent<Image>()).color = ((index % 2 == 0) ? RowEven : RowOdd);
			CreateRowLabel(obj.transform, entry.DisplayName, 14f, new Vector2(96f, 0f), new Vector2(-280f, 0f));
			UnitEditorUiText.ReplaceButtonClick(CreateSmallButton(obj.transform, "Preview", new Vector2(8f, 0f), new Vector2(72f, 32f), (TextAnchor)3), (UnityAction)delegate
			{
				CustomVoicePreview.PlayFile(entry.FileName);
			});
			Button val = CreateSmallButton(obj.transform, "Normal", new Vector2(-248f, 0f), new Vector2(72f, 32f), (TextAnchor)5);
			Button val2 = CreateSmallButton(obj.transform, "Death", new Vector2(-168f, 0f), new Vector2(72f, 32f), (TextAnchor)5);
			UnitEditorUiText.ReplaceButtonClick(CreateSmallButton(obj.transform, "Delete", new Vector2(-88f, 0f), new Vector2(72f, 32f), (TextAnchor)5), (UnityAction)delegate
			{
				DeleteSourceFile(entry.FileName);
			});
			OggRowUi rowUi = new OggRowUi
			{
				FileName = entry.FileName,
				NormalButton = val,
				DeathButton = val2,
				NormalLabel = ((Component)val).GetComponentInChildren<Text>(),
				DeathLabel = ((Component)val2).GetComponentInChildren<Text>()
			};
			if (!NormalByFile.ContainsKey(entry.FileName))
			{
				NormalByFile[entry.FileName] = false;
			}
			if (!DeathByFile.ContainsKey(entry.FileName))
			{
				DeathByFile[entry.FileName] = false;
			}
			UnitEditorUiText.ReplaceButtonClick(val, (UnityAction)delegate
			{
				ToggleNormal(entry.FileName, rowUi);
			});
			UnitEditorUiText.ReplaceButtonClick(val2, (UnityAction)delegate
			{
				ToggleDeath(entry.FileName, rowUi);
			});
			OggRows.Add(rowUi);
			RefreshOggRowVisual(rowUi);
		}

		private static void ToggleNormal(string fileName, OggRowUi rowUi)
		{
			if (!string.IsNullOrEmpty(fileName) && CustomVoiceOggCatalog.IsFileEligible(fileName))
			{
				bool value;
				bool flag = NormalByFile.TryGetValue(fileName, out value) && value;
				if (flag || CountNormalOn() < 5)
				{
					NormalByFile[fileName] = !flag;
					RefreshOggRowVisual(rowUi);
					UpdateSummary();
					RefreshAllOggToggleStates();
				}
			}
		}

		private static void ToggleDeath(string fileName, OggRowUi rowUi)
		{
			if (!string.IsNullOrEmpty(fileName) && CustomVoiceOggCatalog.IsFileEligible(fileName))
			{
				bool value;
				bool flag = DeathByFile.TryGetValue(fileName, out value) && value;
				if (flag || CountDeathOn() < 2)
				{
					DeathByFile[fileName] = !flag;
					RefreshOggRowVisual(rowUi);
					UpdateSummary();
					RefreshAllOggToggleStates();
				}
			}
		}

		private static void RefreshOggRowVisual(OggRowUi rowUi)
		{
			if (rowUi != null)
			{
				bool value;
				bool on = NormalByFile.TryGetValue(rowUi.FileName, out value) && value;
				bool value2;
				bool on2 = DeathByFile.TryGetValue(rowUi.FileName, out value2) && value2;
				SetToggleVisual(rowUi.NormalButton, rowUi.NormalLabel, on, "Normal");
				SetToggleVisual(rowUi.DeathButton, rowUi.DeathLabel, on2, "Death");
			}
		}

		private static void RefreshAllOggToggleStates()
		{
			bool flag = CountNormalOn() >= 5;
			bool flag2 = CountDeathOn() >= 2;
			for (int i = 0; i < OggRows.Count; i++)
			{
				OggRowUi oggRowUi = OggRows[i];
				bool value;
				bool flag3 = NormalByFile.TryGetValue(oggRowUi.FileName, out value) && value;
				bool value2;
				bool flag4 = DeathByFile.TryGetValue(oggRowUi.FileName, out value2) && value2;
				((Selectable)oggRowUi.NormalButton).interactable = flag3 || !flag;
				((Selectable)oggRowUi.DeathButton).interactable = flag4 || !flag2;
			}
		}

		private static void SetToggleVisual(Button button, Text label, bool on, string prefix)
		{
			//IL_0019: 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)
			if ((Object)(object)button != (Object)null)
			{
				((Graphic)((Component)button).GetComponent<Image>()).color = (on ? ToggleOn : ToggleOff);
			}
			if ((Object)(object)label != (Object)null)
			{
				label.text = (on ? (prefix + " ON") : prefix);
			}
		}

		private static int CountNormalOn()
		{
			return NormalByFile.Count((KeyValuePair<string, bool> kv) => kv.Value);
		}

		private static int CountDeathOn()
		{
			return DeathByFile.Count((KeyValuePair<string, bool> kv) => kv.Value);
		}

		private static void UpdateSummary()
		{
			if (!((Object)(object)_summaryText == (Object)null))
			{
				if (_view == CustomVoiceOverlayView.Hub)
				{
					_summaryText.text = $"{CustomVoiceStore.AllPacks.Count} saved voice(s) · {CustomVoiceOggCatalog.GetSummaryText()}";
					return;
				}
				if (CustomVoiceOggCatalog.ScanInProgress)
				{
					_summaryText.text = CustomVoiceOggCatalog.GetSummaryText();
					return;
				}
				_summaryText.text = $"Normal {CountNormalOn()}/{5} · Death {CountDeathOn()}/{2} · {CustomVoiceOggCatalog.GetSummaryText()}";
			}
		}

		private static bool MatchesSearch(string value)
		{
			if (string.IsNullOrWhiteSpace(_search))
			{
				return true;
			}
			return (value ?? string.Empty).IndexOf(_search, StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static void EquipPack(CustomVoicePack pack)
		{
			if (pack != null && CustomVoiceRegistry.TryGetBundle(pack.id, out var bundle))
			{
				UnitEditorManager obj = Object.FindObjectOfType<UnitEditorManager>();
				if (obj != null)
				{
					obj.EquipedVoiceBundle(bundle);
				}
				Close();
			}
		}

		private static void SavePack()
		{
			List<string> list = (from kv in NormalByFile
				where kv.Value && CustomVoiceOggCatalog.IsFileEligible(kv.Key)
				select kv.Key).Take(5).ToList();
			if (list.Count == 0)
			{
				Plugin.LogWarning("Custom voice: assign at least one Normal line before saving.");
				return;
			}
			List<string> list2 = (from kv in DeathByFile
				where kv.Value && CustomVoiceOggCatalog.IsFileEligible(kv.Key)
				select kv.Key).Take(2).ToList();
			if (list2.Count == 0)
			{
				Plugin.LogWarning("Custom voice: assign at least one Death line before saving.");
				return;
			}
			InputField packNameField = _packNameField;
			string text = ((packNameField == null) ? null : packNameField.text?.Trim());
			if (string.IsNullOrWhiteSpace(text))
			{
				text = "Custom Voice";
			}
			CustomVoicePack byId;
			if (!string.IsNullOrEmpty(_editingPackId))
			{
				byId = CustomVoiceStore.GetById(_editingPackId);
				if (byId == null)
				{
					return;
				}
				byId = byId.Clone();
			}
			else
			{
				byId = CustomVoicePack.CreateNew(text);
			}
			byId.name = text;
			byId.vocalFiles = list;
			byId.deathFiles = list2;
			CustomVoiceStore.Save(byId);
			if (CustomVoiceRegistry.TryGetBundle(byId.id, out var bundle))
			{
				UnitEditorManager obj = Object.FindObjectOfType<UnitEditorManager>();
				if (obj != null)
				{
					obj.EquipedVoiceBundle(bundle);
				}
				Close();
			}
		}

		private static void DeleteEditingPack()
		{
			if (!string.IsNullOrEmpty(_editingPackId))
			{
				string editingPackId = _editingPackId;
				CustomVoiceStore.Delete(editingPackId);
				CustomVoiceEditorHelper.RevertEquippedVoiceIfDeleted(editingPackId);
				_editingPackId = null;
				ShowHub();
			}
		}

		private static void DeletePack(CustomVoicePack pack)
		{
			if (pack != null && !string.IsNullOrEmpty(pack.id))
			{
				CustomVoiceStore.Delete(pack.id);
				CustomVoiceEditorHelper.RevertEquippedVoiceIfDeleted(pack.id);
				if (string.Equals(_editingPackId, pack.id, StringComparison.OrdinalIgnoreCase))
				{
					_editingPackId = null;
				}
				RefreshUi();
			}
		}

		private static void DeleteSourceFile(string fileName)
		{
			if (!string.IsNullOrEmpty(fileName) && CustomVoiceOggCatalog.TryDeleteSourceFile(fileName))
			{
				NormalByFile.Remove(fileName);
				DeathByFile.Remove(fileName);
				RefreshUi();
			}
		}

		private static void ClearListRows()
		{
			OggRows.Clear();
			if (!((Object)(object)_listContent == (Object)null))
			{
				for (int num = _listContent.childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)_listContent.GetChild(num)).gameObject);
				}
			}
		}

		private static GameObject CreateRowShell(int id)
		{
			//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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			GameObject val = new GameObject("Row_" + id, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(LayoutElement)
			});
			val.transform.SetParent(_listContent, false);
			LayoutElement component = val.GetComponent<LayoutElement>();
			component.minHeight = 48f;
			component.preferredHeight = 48f;
			return val;
		}

		private static void CreateRowLabel(Transform parent, string text, float fontSize, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_003c: 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_004d: 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)
			GameObject val = new GameObject("Label", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = offsetMin;
			component.offsetMax = offsetMax;
			Text obj = val.AddComponent<Text>();
			obj.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			obj.fontSize = (int)fontSize;
			obj.alignment = (TextAnchor)3;
			((Graphic)obj).color = Color.white;
			obj.text = text;
		}

		private static void CreateRowIcon(Transform parent, Sprite sprite)
		{
			//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_0037: 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_005d: 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_0087: 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)
			GameObject val = new GameObject("Icon", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0.5f);
			component.anchorMax = new Vector2(0f, 0.5f);
			component.pivot = new Vector2(0f, 0.5f);
			component.anchoredPosition = new Vector2(8f, 0f);
			component.sizeDelta = new Vector2(36f, 36f);
			val.GetComponent<Image>().sprite = sprite;
		}

		private static Button CreateSmallButton(Transform parent, string label, Vector2 anchoredPosition, Vector2 size, TextAnchor anchor)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			//IL_00a3: 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_00cd: 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_0077: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: 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_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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)
			GameObject val = new GameObject("Btn_" + label, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			if ((int)anchor == 5)
			{
				component.anchorMin = new Vector2(1f, 0.5f);
				component.anchorMax = new Vector2(1f, 0.5f);
				component.pivot = new Vector2(1f, 0.5f);
			}
			else
			{
				component.anchorMin = new Vector2(0f, 0.5f);
				component.anchorMax = new Vector2(0f, 0.5f);
				component.pivot = new Vector2(0f, 0.5f);
			}
			component.anchoredPosition = anchoredPosition;
			component.sizeDelta = size;
			((Graphic)val.GetComponent<Image>()).color = ToggleOff;
			GameObject val2 = new GameObject("Label", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(val.transform, false);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			Text obj = val2.AddComponent<Text>();
			obj.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			obj.fontSize = 12;
			obj.alignment = (TextAnchor)4;
			((Graphic)obj).color = Color.white;
			obj.text = label;
			return val.GetComponent<Button>();
		}

		private static void EnsureBuilt()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0086: 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_013d: 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_0176: 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_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: 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_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Expected O, but got Unknown
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: 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_0400: Expected O, but got Unknown
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0447: Unknown result type (might be due to invalid IL or missing references)
			//IL_0451: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_0497: 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_04ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Expected O, but got Unknown
			//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0605: Unknown result type (might be due to invalid IL or missing references)
			//IL_062a: Unknown result type (might be due to invalid IL or missing references)
			//IL_064c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0651: Unknown result type (might be due to invalid IL or missing references)
			//IL_0664: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_072e: Unknown result type (might be due to invalid IL or missing references)
			//IL_073d: 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_077f: Unknown result type (might be due to invalid IL or missing references)
			//IL_079d: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0800: Unknown result type (might be due to invalid IL or missing references)
			//IL_081b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0835: Unknown result type (might be due to invalid IL or missing references)
			//IL_084f: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c7: Expected O, but got Unknown
			//IL_089c: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0909: Unknown result type (might be due to invalid IL or missing references)
			//IL_092c: Unknown result type (might be due to invalid IL or missing references)
			//IL_093b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0973: Unknown result type (might be due to invalid IL or missing references)
			//IL_0982: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a1c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a2b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a44: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a5d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a67: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b11: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b16: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b29: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b34: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b48: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b5e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b74: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b80: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b96: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0869: Unknown result type (might be due to invalid IL or missing references)
			//IL_086e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0874: Expected O, but got Unknown
			if (HasStaleOverlayUi())
			{
				Object.Destroy((Object)(object)_canvasRoot);
				ResetOverlayRefs();
			}
			if (!((Object)(object)_canvasRoot != (Object)null))
			{
				_canvasRoot = new GameObject("TabsUnlimited_CustomVoiceOverlay", new Type[1] { typeof(RectTransform) });
				Object.DontDestroyOnLoad((Object)(object)_canvasRoot);
				Canvas obj = _canvasRoot.AddComponent<Canvas>();
				obj.renderMode = (RenderMode)0;
				obj.sortingOrder = 20000;
				CanvasScaler obj2 = _canvasRoot.AddComponent<CanvasScaler>();
				obj2.uiScaleMode = (ScaleMode)1;
				obj2.referenceResolution = new Vector2(1280f, 720f);
				_canvasRoot.AddComponent<GraphicRaycaster>();
				GameObject val = CreatePanel(_canvasRoot.transform, "Backdrop", new Color(0f, 0f, 0f, 0.55f));
				StretchFull(val.GetComponent<RectTransform>());
				Button obj3 = val.AddComponent<Button>();
				((Selectable)obj3).targetGraphic = (Graphic)(object)val.GetComponent<Image>();
				object obj4 = <>O.<5>__Close;
				if (obj4 == null)
				{
					UnityAction val2 = Close;
					<>O.<5>__Close = val2;
					obj4 = (object)val2;
				}
				UnitEditorUiText.ReplaceButtonClick(obj3, (UnityAction)obj4);
				_panel = CreatePanel(_canvasRoot.transform, "Panel", new Color(0.06f, 0.06f, 0.07f, 0.98f));
				RectTransform component = _panel.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0.06f, 0.06f);
				component.anchorMax = new Vector2(0.94f, 0.94f);
				component.offsetMin = Vector2.zero;
				component.offsetMax = Vector2.zero;
				GameObject val3 = CreatePanel(_panel.transform, "Header", new Color(0.08f, 0.08f, 0.09f, 1f));
				_headerRect = val3.GetComponent<RectTransform>();
				_headerRect.anchorMin = new Vector2(0f, 1f);
				_headerRect.anchorMax = new Vector2(1f, 1f);
				_headerRect.pivot = new Vector2(0.5f, 1f);
				_headerRect.sizeDelta = new Vector2(0f, 148f);
				_headerRect.anchoredPosition = Vector2.zero;
				_titleText = CreateStaticText(val3.transform, "Title", 18, (TextAnchor)0, new Vector2(16f, -8f), new Vector2(-120f, -28f), "CUSTOM VOICES");
				_instructionsText = CreateStaticText(val3.transform, "Instructions", 12, (TextAnchor)0, new Vector2(16f, -42f), new Vector2(-16f, -96f), string.Empty);
				((Graphic)_instructionsText).color = new Color(0.72f, 0.72f, 0.75f, 1f);
				_instructionsText.horizontalOverflow = (HorizontalWrapMode)0;
				_instructionsText.verticalOverflow = (VerticalWrapMode)1;
				_summaryText = CreateStaticText(val3.transform, "Summary", 13, (TextAnchor)0, new Vector2(16f, -100f), new Vector2(-16f, -120f), string.Empty);
				_packNameContainer = new GameObject("PackNameRow", new Type[1] { typeof(RectTransform) });
				_packNameContainer.transform.SetParent(val3.transform, false);
				RectTransform component2 = _packNameContainer.GetComponent<RectTransform>();
				component2.anchorMin = new Vector2(0f, 1f);
				component2.anchorMax = new Vector2(0f, 1f);
				component2.pivot = new Vector2(0f, 1f);
				component2.anchoredPosition = new Vector2(16f, -124f);
				component2.sizeDelta = new Vector2(280f, 24f);
				GameObject val4 = new GameObject("PackNameInput", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val4.transform.SetParent(_packNameContainer.transform, false);
				RectTransform component3 = val4.GetComponent<RectTransform>();
				component3.anchorMin = new Vector2(0f, 0f);
				component3.anchorMax = new Vector2(1f, 1f);
				component3.offsetMin = Vector2.zero;
				component3.offsetMax = Vector2.zero;
				((Graphic)val4.GetComponent<Image>()).color = new Color(0.14f, 0.14f, 0.16f, 1f);
				GameObject val5 = new GameObject("Text", new Type[1] { typeof(RectTransform) });
				val5.transform.SetParent(val4.transform, false);
				StretchFull(val5.GetComponent<RectTransform>(), 8f, 2f, -8f, -2f);
				Text val6 = val5.AddComponent<Text>();
				val6.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
				val6.fontSize = 14;
				((Graphic)val6).color = Color.white;
				val6.supportRichText = false;
				_packNameField = val4.AddComponent<InputField>();
				_packNameField.textComponent = val6;
				_packNameField.placeholder = (Graphic)(object)CreateInputPlaceholder(val4.transform, "Name");
				_packNameField.text = string.Empty;
				_packNameContainer.SetActive(false);
				GameObject val7 = new GameObject("Search", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val7.transform.SetParent(val3.transform, false);
				_searchRect = val7.GetComponent<RectTransform>();
				_searchRect.anchorMin = new Vector2(0f, 0f);
				_searchRect.anchorMax = new Vector2(1f, 0f);
				_searchRect.pivot = new Vector2(0.5f, 0f);
				_searchRect.anchoredPosition = new Vector2(0f, 12f);
				_searchRect.sizeDelta = new Vector2(-140f, 32f);
				((Graphic)val7.GetComponent<Image>()).color = new Color(0.14f, 0.14f, 0.16f, 1f);
				GameObject val8 = new GameObject("Text", new Type[1] { typeof(RectTransform) });
				val8.transform.SetParent(val7.transform, false);
				StretchFull(val8.GetComponent<RectTransform>(), 8f, 4f, -8f, -4f);
				Text val9 = val8.AddComponent<Text>();
				val9.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
				val9.fontSize = 14;
				((Graphic)val9).color = Color.white;
				val9.supportRichText = false;
				_searchField = val7.AddComponent<InputField>();
				_searchField.textComponent = val9;
				_searchField.placeholder = (Graphic)(object)CreateInputPlaceholder(val7.transform, "Search");
				((UnityEvent<string>)(object)_searchField.onValueChanged).AddListener((UnityAction<string>)delegate(string value)
				{
					_search = value ?? string.Empty;
					RefreshUi();
				});
				_openFolderButton = CreateSmallButton(val3.transform, "Open File", new Vector2(-112f, 12f), new Vector2(96f, 32f), (TextAnchor)5);
				((Component)_openFolderButton).GetComponent<RectTransform>().anchorMin = new Vector2(1f, 0f);
				((Component)_openFolderButton).GetComponent<RectTransform>().anchorMax = new Vector2(1f, 0f);
				((Component)_openFolderButton).GetComponent<RectTransform>().pivot = new Vector2(1f, 0f);
				Button openFolderButton = _openFolderButton;
				object obj5 = <>O.<6>__OpenSourcesFolder;
				if (obj5 == null)
				{
					UnityAction val10 = CustomVoiceOggImporter.OpenSourcesFolder;
					<>O.<6>__OpenSourcesFolder = val10;
					obj5 = (object)val10;
				}
				UnitEditorUiText.ReplaceButtonClick(openFolderButton, (UnityAction)obj5);
				((Component)_openFolderButton).gameObject.SetActive(false);
				Button obj6 = CreateSmallButton(val3.transform, "Close", new Vector2(-12f, -12f), new Vector2(96f, 32f), (TextAnchor)5);
				((Component)obj6).GetComponent<RectTransform>().anchorMin = new Vector2(1f, 1f);
				((Component)obj6).GetComponent<RectTransform>().anchorMax = new Vector2(1f, 1f);
				((Component)obj6).GetComponent<RectTransform>().pivot = new Vector2(1f, 1f);
				object obj7 = <>O.<5>__Close;
				if (obj7 == null)
				{
					UnityAction val11 = Close;
					<>O.<5>__Close = val11;
					obj7 = (object)val11;
				}
				UnitEditorUiText.ReplaceButtonClick(obj6, (UnityAction)obj7);
				_footer = CreatePanel(_panel.transform, "Footer", new Color(0.08f, 0.08f, 0.09f, 1f));
				RectTransform component4 = _footer.GetComponent<RectTransform>();
				component4.anchorMin = new Vector2(0f, 0f);
				component4.anchorMax = new Vector2(1f, 0f);
				component4.pivot = new Vector2(0.5f, 0f);
				component4.sizeDelta = new Vector2(0f, 52f);
				component4.anchoredPosition = Vector2.zero;
				_footerSecondary = CreateSmallButton(_footer.transform, "Back", new Vector2(16f, 10f), new Vector2(96f, 32f), (TextAnchor)3);
				_footerSecondaryLabel = ((Component)_footerSecondary).GetComponentInChildren<Text>();
				_footerDelete = CreateSmallButton(_footer.transform, "Delete", new Vector2(120f, 10f), new Vector2(96f, 32f), (TextAnchor)3);
				_footerPrimary = CreateSmallButton(_footer.transform, "Save", new Vector2(-16f, 10f), new Vector2(96f, 32f), (TextAnchor)5);
				_footerPrimaryLabel = ((Component)_footerPrimary).GetComponentInChildren<Text>();
				GameObject val12 = new GameObject("ScrollHost", new Type[1] { typeof(RectTransform) });
				val12.transform.SetParent(_panel.transform, false);
				_scrollHostRect = val12.GetComponent<RectTransform>();
				_scrollHostRect.anchorMin = Vector2.zero;
				_scrollHostRect.anchorMax = Vector2.one;
				_scrollHostRect.offsetMin = new Vector2(8f, 56f);
				_scrollHostRect.offsetMax = new Vector2(-8f, -152f);
				_scrollRect = val12.AddComponent<ScrollRect>();
				_scrollRect.horizontal = false;
				_scrollRect.movementType = (MovementType)2;
				GameObject val13 = CreatePanel(val12.transform, "Viewport", new Color(0f, 0f, 0f, 0.15f));
				StretchFull(val13.GetComponent<RectTransform>());
				val13.AddComponent<Mask>().showMaskGraphic = false;
				GameObject val14 = new GameObject("Content", new Type[3]
				{
					typeof(RectTransform),
					typeof(VerticalLayoutGroup),
					typeof(ContentSizeFitter)
				});
				val14.transform.SetParent(val13.transform, false);
				_listContent = val14.transform;
				RectTransform component5 = val14.GetComponent<RectTransform>();
				component5.anchorMin = new Vector2(0f, 1f);
				component5.anchorMax = new Vector2(1f, 1f);
				component5.pivot = new Vector2(0.5f, 1f);
				component5.anchoredPosition = Vector2.zero;
				component5.sizeDelta = new Vector2(0f, 0f);
				VerticalLayoutGroup component6 = val14.GetComponent<VerticalLayoutGroup>();
				((HorizontalOrVerticalLayoutGroup)component6).childControlHeight = true;
				((HorizontalOrVerticalLayoutGroup)component6).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)component6).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)component6).childForceExpandWidth = true;
				((HorizontalOrVerticalLayoutGroup)component6).spacing = 2f;
				val14.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
				_scrollRect.viewport = val13.GetComponent<RectTransform>();
				_scrollRect.content = component5;
				_canvasRoot.SetActive(false);
			}
		}

		private static bool HasStaleOverlayUi()
		{
			if ((Object)(object)_canvasRoot == (Object)null)
			{
				return false;
			}
			if ((Object)(object)_instructionsText == (Object)null)
			{
				return true;
			}
			Transform[] componentsInChildren = _canvasRoot.GetComponentsInChildren<Transform>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (((Object)componentsInChildren[i]).name == "Btn_Add OGG")
				{
					return true;
				}
			}
			return false;
		}

		private static void ResetOverlayRefs()
		{
			_canvasRoot = null;
			_panel = null;
			_headerRect = null;
			_scrollHostRect = null;
			_titleText = null;
			_instructionsText = null;
			_summaryText = null;
			_searchField = null;
			_searchRect = null;
			_packNameContainer = null;
			_packNameField = null;
			_openFolderButton = null;
			_listContent = null;
			_scrollRect = null;
			_footer = null;
			_footerPrimary = null;
			_footerSecondary = null;
			_footerDelete = null;
			_footerPrimaryLabel = null;
			_footerSecondaryLabel = null;
		}

		private static GameObject CreatePanel(Transform parent, string name, Color color)
		{
			//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_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)
			//IL_0040: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			((Graphic)val.GetComponent<Image>()).color = color;
			return val;
		}

		private static Text CreateInputPlaceholder(Transform parent, string placeholderText)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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 = new GameObject("Placeholder", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			StretchFull(val.GetComponent<RectTransform>(), 8f, 2f, -8f, -2f);
			Text obj = val.AddComponent<Text>();
			obj.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			obj.fontSize = 14;
			obj.fontStyle = (FontStyle)2;
			((Graphic)obj).color = new Color(0.55f, 0.55f, 0.58f, 1f);
			obj.text = placeholderText;
			obj.supportRichText = false;
			return obj;
		}

		private static Text CreateStaticText(Transform parent, string name, int fontSize, TextAnchor anchor, Vector2 offsetMin, Vector2 offsetMax, string text)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_004c: 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_006c: 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_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)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.offsetMin = offsetMin;
			component.offsetMax = offsetMax;
			Text obj = val.AddComponent<Text>();
			obj.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			obj.fontSize = fontSize;
			obj.alignment = anchor;
			((Graphic)obj).color = Color.white;
			obj.text = text;
			return obj;
		}

		private static void StretchFull(RectTransform rect, float left = 0f, float bottom = 0f, float right = 0f, float top = 0f)
		{
			//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_0019: 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)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = new Vector2(left, bottom);
			rect.offsetMax = new Vector2(0f - right, 0f - top);
		}
	}
	internal static class EcsComponentHelper
	{
		private static readonly Type GameObjectEntityType = AccessTools.TypeByName("GameObjectEntity") ?? AccessTools.TypeByName("Unity.Entities.Hybrid.GameObjectEntity, Unity.Entities.Hybrid");

		private static readonly PropertyInfo GoEntityEntityProperty = ((GameObjectEntityType != null) ? AccessTools.Property(GameObjectEntityType, "Entity") : null);

		private static readonly PropertyInfo GoEntityManagerProperty = ((GameObjectEntityType != null) ? AccessTools.Property(GameObjectEntityType, "EntityManager") : null);

		private static readonly PropertyInfo WorldActiveProperty = AccessTools.Property(typeof(World), "Active");

		private static readonly MethodInfo GetExistingManagerMethod = AccessTools.Method(typeof(World), "GetExistingManager", (Type[])null, (Type[])null);

		internal static bool IsAvailable
		{
			get
			{
				if (GameObjectEntityType != null && GoEntityEntityProperty != null && GoEntityManagerProperty != null && WorldActiveProperty != null)
				{
					return GetExistingManagerMethod != null;
				}
				return false;
			}
		}

		internal static World GetActiveWorld()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			return (World)(WorldActiveProperty?.GetValue(null, null));
		}

		internal static TManager GetExistingManager<TManager>() where TManager : class
		{
			World activeWorld = GetActiveWorld();
			if (activeWorld == null || GetExistingManagerMethod == null)
			{
				return null;
			}
			return (TManager)GetExistingManagerMethod.MakeGenericMethod(typeof(TManager)).Invoke(activeWorld, null);
		}

		internal static bool TryGetEntityManager(Component component, out Entity entity, out EntityManager entityManager)
		{
			//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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			entity = Entity.Null;
			entityManager = null;
			if ((Object)(object)component == (Object)null || GameObjectEntityType == null)
			{
				return false;
			}
			Component component2 = component.GetComponent(GameObjectEntityType);
			if ((Object)(object)component2 == (Object)null)
			{
				return false;
			}
			entity = (Entity)GoEntityEntityProperty.GetValue(component2, null);
			entityManager = (EntityManager)GoEntityManagerProperty.GetValue(component2, null);
			return entityManager.IsCreated;
		}

		internal static bool TryGetComponentData<T>(EntityManager entityManager, Entity entity, out T data) where T : struct, IComponentData
		{
			//IL_0010: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			data = default(T);
			if (!entityManager.IsCreated || !entityManager.Exists(entity) || !entityManager.HasComponent<T>(entity))
			{
				return false;
			}
			data = entityManager.GetComponentData<T>(entity);
			return true;
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct EnemyHighestPriceTargeting : ITargetingComponent, IComponentData
	{
	}
	[Serializable]
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct EnemyLowestHealthTargeting : ITargetingComponent, IComponentData
	{
	}
	[Serializable]
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct EnemyRangedMixedTargeting : ITargetingComponent, IComponentData
	{
	}
	internal static class FleeDistanceEditorDefaults
	{
		internal const bool RangedUntilFleeEnabled = true;

		internal const float Default = 5f;

		internal const float Min = 1f;

		internal const float Max = 30f;
	}
	internal static class FleeDistanceHelper
	{
		private const float RangedAttackRangeThreshold = 5f;

		private const float FallbackWaitingDistance = 100f;

		private const float WeaponRangeBuffer = 0.3f;

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

		private static readonly Dictionary<DatabaseID, float> DistanceByBlueprintGuid = new Dictionary<DatabaseID, float>();

		private static float? _cachedVanillaWaitingDistance;

		internal static bool HasKeepRangedDistanceMovement(IReadOnlyList<IMovementComponent> movementComponents)
		{
			if (movementComponents == null)
			{
				return false;
			}
			for (int i = 0; i < movementComponents.Count; i++)
			{
				if (movementComponents[i] is KeepRangedDistance)
				{
					return true;
				}
			}
			return false;
		}

		internal static bool HasFleeDistanceMovement(IReadOnlyList<IMovementComponent> movementComponents)
		{
			if (movementComponents == null)
			{
				return false;
			}
			for (int i = 0; i < movementComponents.Count; i++)
			{
				if (movementComponents[i] is FleeDistance)
				{
					return true;
				}
			}
			return false;
		}

		internal static float ReadComponentFleeDistance(UnitBlueprint blueprint)
		{
			return ReadFromMovementComponents(blueprint?.MovementComponents);
		}

		internal static bool TryGetCachedDistance(UnitBlueprint blueprint, out float distance)
		{
			//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_0048: 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_0051: 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)
			distance = 0f;
			if ((Object)(object)blueprint == (Object)null)
			{
				return false;
			}
			int instanceID = ((Object)blueprint).GetInstanceID();
			if (DistanceByBlueprintId.TryGetValue(instanceID, out distance) && distance > 0f)
			{
				return true;
			}
			if (blueprint.Entity == null)
			{
				return false;
			}
			DatabaseID gUID = blueprint.Entity.GUID;
			if (gUID == default(DatabaseID))
			{
				return false;
			}
			if (!DistanceByBlueprintGuid.TryGetValue(gUID, out distance) || distance <= 0f)
			{
				return false;
			}
			DistanceByBlueprintId[instanceID] = distance;
			return true;
		}

		internal static float GetFleeDistance(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null)
			{
				return 5f;
			}
			float num = ReadFromMovementComponents(blueprint.MovementComponents);
			if (TryGetCachedDistance(blueprint, out var distance) && (num <= 0f || (Mathf.Approximately(num, 5f) && !Mathf.Approximately(distance, num))))
			{
				return distance;
			}
			if (num > 0f)
			{
				return num;
			}
			return 5f;
		}

		internal static void SetFleeDistance(UnitBlueprint blueprint, float distanceMeters)
		{
			if (!((Object)(object)blueprint == (Object)null))
			{
				distanceMeters = ClampDistance(distanceMeters);
				CacheDistance(blueprint, distanceMeters);
				EnsureFleeDistanceComponent(blueprint, distanceMeters);
			}
		}

		internal static void EnsureFleeDistanceComponent(UnitBlueprint blueprint, float distanceMeters)
		{
			//IL_007c: 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_003f: 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)
			if ((Object)(object)blueprint == (Object)null)
			{
				return;
			}
			distanceMeters = ClampDistance(distanceMeters);
			CacheDistance(blueprint, distanceMeters);
			List<IMovementComponent> list = blueprint.MovementComponents ?? new List<IMovementComponent>();
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i] is FleeDistance)
				{
					list[i] = (IMovementComponent)(object)new FleeDistance
					{
						Value = distanceMeters
					};
					blueprint.MovementComponents = list;
					EnsureRangedMovementForFleeUnit(blueprint);
					return;
				}
			}
			list.Clear();
			list.Add((IMovementComponent)(object)new FleeDistance
			{
				Value = distanceMeters
			});
			blueprint.MovementComponents = list;
			EnsureRangedMovementForFleeUnit(blueprint);
		}

		internal static void EnsureRangedMovementForFleeUnit(UnitBlueprint blueprint)
		{
			//IL_008e: 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_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_0054: 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)
			if ((Object)(object)blueprint == (Object)null || !HasFleeDistanceMovement(blueprint.MovementComponents) || !IsRangedFleeUnit(blueprint))
			{
				return;
			}
			List<IMovementComponent> list = blueprint.MovementComponents ?? new List<IMovementComponent>();
			float waitingDistance = ResolveWaitingDistance(blueprint);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i] is KeepRangedDistance val)
				{
					if (val.WaitingDistance <= 0f)
					{
						val.WaitingDistance = waitingDistance;
						list[i] = (IMovementComponent)(object)val;
						blueprint.MovementComponents = list;
					}
					return;
				}
			}
			list.Add((IMovementComponent)(object)new KeepRangedDistance
			{
				WaitingDistance = waitingDistance
			});
			blueprint.MovementComponents = list;
		}

		internal static void RestoreFleeDistanceValue(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null)
			{
				return;
			}
			if (FleeDistanceMetadata.TryParse(blueprint.UnitDescription, out var fleeDistanceMeters, out var _))
			{
				SetFleeDistance(blueprint, fleeDistanceMeters);
				EnsureRangedMovementForFleeUnit(blueprint);
			}
			else
			{
				if (!HasFleeDistanceMovement(blueprint.MovementComponents))
				{
					return;
				}
				float num = ReadFromMovementComponents(blueprint.MovementComponents);
				if (TryGetCachedDistance(blueprint, out var distance) && distance > 0f && (num <= 0f || (Mathf.Approximately(num, 5f) && !Mathf.Approximately(distance, num))))
				{
					SetFleeDistance(blueprint, distance);
					EnsureRangedMovementForFleeUnit(blueprint);
					return;
				}
				if (num <= 0f)
				{
					SetFleeDistance(blueprint, 5f);
				}
				EnsureRangedMovementForFleeUnit(blueprint);
			}
		}

		internal static float ClampDistance(float distanceWm)
		{
			if (distanceWm <= 0f)
			{
				distanceWm = 5f;
			}
			return Mathf.Clamp(distanceWm, 1f, 30f);
		}

		internal static bool IsRangedFleeUnit(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null)
			{
				return false;
			}
			return GetMaxWeaponRange(blueprint) >= 5f;
		}

		private static void CacheDistance(UnitBlueprint blueprint, float distanceMeters)
		{
			//IL_0020: 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_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_003d: Unknown result type (might be due to invalid IL or missing references)
			DistanceByBlueprintId[((Object)blueprint).GetInstanceID()] = distanceMeters;
			if (blueprint.Entity != null)
			{
				DatabaseID gUID = blueprint.Entity.GUID;
				if (!(gUID == default(DatabaseID)))
				{
					DistanceByBlueprintGuid[gUID] = distanceMeters;
				}
			}
		}

		private static float ResolveWaitingDistance(UnitBlueprint blueprint)
		{
			float? num = TryGetVanillaWaitingDistance();
			if (num.HasValue)
			{
				return num.Value;
			}
			float maxWeaponRange = GetMaxWeaponRange(blueprint);
			if (maxWeaponRange >= 5f)
			{
				return maxWeaponRange + 0.3f;
			}
			return 100f;
		}

		private static float? TryGetVanillaWaitingDistance()
		{
			if (_cachedVanillaWaitingDistance.HasValue)
			{
				return _cachedVanillaWaitingDistance.Value;
			}
			ContentDatabase val = ContentDatabase.Instance();
			if (val == null)
			{
				return null;
			}
			foreach (UnitBlueprint item in val.GetAllUnitBlueprints() ?? Enumerable.Empty<UnitBlueprint>())
			{
				if (!((Object)(object)item == (Object)null) && !item.IsCustomUnit && TryGetKeepRangedWaitingDistance(item.MovementComponents, out var waitingDistance))
				{
					_cachedVanillaWaitingDistance = waitingDistance;
					return waitingDistance;
				}
			}
			return null;
		}

		private static bool TryGetKeepRangedWaitingDistance(IReadOnlyList<IMovementComponent> movementComponents, out float waitingDistance)
		{
			//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_0027: 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)
			waitingDistance = 0f;
			if (movementComponents == null)
			{
				return false;
			}
			for (int i = 0; i < movementComponents.Count; i++)
			{
				if (movementComponents[i] is KeepRangedDistance val && !(val.WaitingDistance <= 0f))
				{
					waitingDistance = val.WaitingDistance;
					return true;
				}
			}
			return false;
		}

		private static float GetMaxWeaponRange(UnitBlueprint blueprint)
		{
			float num = 0f;
			if ((Object)(object)blueprint.RightWeapon != (Object)null)
			{
				RangeWeapon component = blueprint.RightWeapon.GetComponent<RangeWeapon>();
				if ((Object)(object)component != (Object)null)
				{
					num = Mathf.Max(num, ((Weapon)component).maxRange);
				}
			}
			if ((Object)(object)blueprint.LeftWeapon != (Object)null)
			{
				RangeWeapon component2 = blueprint.LeftWeapon.GetComponent<RangeWeapon>();
				if ((Object)(object)component2 != (Object)null)
				{
					num = Mathf.Max(num, ((Weapon)component2).maxRange);
				}
			}
			return num;
		}

		private static float ReadFromMovementComponents(IReadOnlyList<IMovementComponent> movementComponents)
		{
			//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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (movementComponents == null)
			{
				return 0f;
			}
			for (int i = 0; i < movementComponents.Count; i++)
			{
				if (movementComponents[i] is FleeDistance val && val.Value > 0f)
				{
					return val.Value;
				}
			}
			return 0f;
		}
	}
	internal static class FleeDistanceMetadata
	{
		private const string TagPattern = "\\u200B?\\[\\[TU:flee=([0-9]+(?:\\.[0-9]+)?)\\]\\]";

		private static readonly Regex TagRegex = new Regex("\\u200B?\\[\\[TU:flee=([0-9]+(?:\\.[0-9]+)?)\\]\\]", RegexOptions.Compiled);

		internal static string Strip(string description)
		{
			if (string.IsNullOrEmpty(description))
			{
				return string.Empty;
			}
			return TagRegex.Replace(description, string.Empty).TrimEnd(Array.Empty<char>());
		}

		internal static string EmbedForSave(string description, float fleeDistanceMeters)
		{
			string text = Strip(description);
			if (fleeDistanceMeters <= 0f)
			{
				return text;
			}
			return text + "\u200b[[TU:flee=" + fleeDistanceMeters.ToString("0.##", CultureInfo.InvariantCulture) + "]]";
		}

		internal static bool TryParse(string description, out float fleeDistanceMeters, out string cleanDescription)
		{
			cleanDescription = Strip(description);
			fleeDistanceMeters = 0f;
			if (string.IsNullOrEmpty(description))
			{
				return false;
			}
			Match match = TagRegex.Match(description);
			if (!match.Success)
			{
				return false;
			}
			return float.TryParse(match.Groups[1].Value, NumberStyles.Float, CultureInfo.InvariantCulture, out fleeDistanceMeters);
		}
	}
	internal static class FleeDistanceRuntimeFix
	{
		public static void DeserializedUnit_Postfix(ref UnitBlueprint __result)
		{
			FleeDistanceHelper.RestoreFleeDistanceValue(__result);
		}

		public static void Spawn_Prefix(UnitBlueprint __instance)
		{
			FleeDistanceHelper.RestoreFleeDistanceValue(__instance);
		}
	}
	internal static class FootstepBlueprintHelper
	{
		private static readonly FieldInfo FootRefField = AccessTools.Field(typeof(UnitBlueprint), "footRef");

		private static readonly FieldInfo FootPathDataField = AccessTools.Field(typeof(UnitBlueprint), "footPathData");

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

		internal static string GetFootRef(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null || FootRefField == null)
			{
				return "Footsteps/Normal";
			}
			string text = FootRefField.GetValue(blueprint) as string;
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return "Footsteps/Normal";
		}

		internal static void SetFootRef(UnitBlueprint blueprint, string audioRef)
		{
			if (!((Object)(object)blueprint == (Object)null) && !(FootRefField == null))
			{
				FootRefField.SetValue(blueprint, string.IsNullOrEmpty(audioRef) ? "Footsteps/Normal" : audioRef);
				SyncFootPathData(blueprint);
			}
		}

		internal static float GetFootPitch(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null)
			{
				return 1f;
			}
			int instanceID = ((Object)blueprint).GetInstanceID();
			if (PitchByBlueprintId.TryGetValue(instanceID, out var value) && value > 0f)
			{
				return value;
			}
			return 1f;
		}

		internal static void SetFootPitch(UnitBlueprint blueprint, float pitch)
		{
			if (!((Object)(object)blueprint == (Object)null))
			{
				if (pitch <= 0f)
				{
					pitch = 1f;
				}
				PitchByBlueprintId[((Object)blueprint).GetInstanceID()] = pitch;
				SyncFootPathData(blueprint);
			}
		}

		internal static AudioPathData BuildFootPathData(string audioRef, float pitch)
		{
			if (pitch <= 0f)
			{
				pitch = 1f;
			}
			string obj = (string.IsNullOrEmpty(audioRef) ? "Footsteps/Normal" : audioRef);
			AudioPathData val = null;
			if (!AudioPathData.ValidateAndAssignPathData(obj, ref val, (Object)null) || val == null)
			{
				return null;
			}
			val.EffectPitch = pitch;
			return val;
		}

		internal static void SyncFootPathData(UnitBlueprint blueprint)
		{
			if (!((Object)(object)blueprint == (Object)null) && !(FootPathDataField == null))
			{
				AudioPathData val = BuildFootPathData(GetFootRef(blueprint), GetFootPitch(blueprint));
				if (val != null)
				{
					FootPathDataField.SetValue(blueprint, val);
				}
			}
		}

		internal static void PlayPreviewSound(string audioRef, float pitch)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			AudioPathData val = BuildFootPathData(audioRef, pitch);
			if (val != null)
			{
				if (pitch <= 0f)
				{
					pitch = 1f;
				}
				SoundPlayer service = ServiceLocator.GetService<SoundPlayer>();
				if (service != null)
				{
					service.PlaySoundEffectNonAlloc(val, 5f, Vector3.zero, (MaterialType)0, (Transform)null, pitch);
				}
			}
		}

		internal static void ApplyPitchToPathData(UnitBlueprint blueprint, float pitch)
		{
			if (!((Object)(object)blueprint == (Object)null) && !(FootPathDataField == null))
			{
				object value = FootPathDataField.GetValue(blueprint);
				value?.GetType().GetField("EffectPitch")?.SetValue(value, (pitch <= 0f) ? 1f : pitch);
			}
		}

		internal static void ClearRuntimePitch(UnitBlueprint blueprint)
		{
			if (!((Object)(object)blueprint == (Object)null))
			{
				PitchByBlueprintId.Remove(((Object)blueprint).GetInstanceID());
			}
		}
	}
	internal sealed class FootstepDef
	{
		internal readonly string EffectId;

		internal readonly string DisplayName;

		internal string AudioRef => "Footsteps/" + EffectId;

		internal FootstepDef(string effectId, string displayName)
		{
			EffectId = effectId;
			DisplayName = displayName;
		}
	}
	internal static class FootstepCatalog
	{
		internal const string DefaultEffectId = "Normal";

		internal const string DefaultAudioRef = "Footsteps/Normal";

		internal static readonly FootstepDef[] All = new FootstepDef[13]
		{
			new FootstepDef("Normal", "NORMAL"),
			new FootstepDef("Small", "SMALL"),
			new FootstepDef("Medium", "MEDIUM"),
			new FootstepDef("Big", "BIG"),
			new FootstepDef("Mammoth", "MAMMOTH"),
			new FootstepDef("Minotaur", "MINOTAUR"),
			new FootstepDef("Bear", "BEAR"),
			new FootstepDef("IceGiant", "ICE GIANT"),
			new FootstepDef("Snake", "SNAKE"),
			new FootstepDef("Horse", "HORSE"),
			new FootstepDef("Raptor", "RAPTOR"),
			new FootstepDef("Bat", "BAT"),
			new FootstepDef("Skeleton", "SKELETON")
		};

		internal static FootstepDef GetByEffectId(string effectId)
		{
			if (string.IsNullOrEmpty(effectId))
			{
				return All[0];
			}
			for (int i = 0; i < All.Length; i++)
			{
				if (string.Equals(All[i].EffectId, effectId, StringComparison.OrdinalIgnoreCase))
				{
					return All[i];
				}
			}
			return All[0];
		}

		internal static FootstepDef GetByAudioRef(string audioRef)
		{
			if (string.IsNullOrEmpty(audioRef))
			{
				return All[0];
			}
			for (int i = 0; i < All.Length; i++)
			{
				if (string.Equals(All[i].AudioRef, audioRef, StringComparison.OrdinalIgnoreCase))
				{
					return All[i];
				}
			}
			if (audioRef.StartsWith("Footsteps/", StringComparison.OrdinalIgnoreCase))
			{
				return GetByEffectId(audioRef.Substring("Footsteps/".Length));
			}
			return All[0];
		}

		internal static string EffectIdFromAudioRef(string audioRef)
		{
			return GetByAudioRef(audioRef).EffectId;
		}
	}
	internal static class FootstepIconResolver
	{
		private static readonly Dictionary<string, Sprite> Cache = new Dictionary<string, Sprite>(StringComparer.OrdinalIgnoreCase);

		private static bool _scanned;

		internal static void WarmCache()
		{
			EnsureScanned();
		}

		internal static Sprite GetIcon(FootstepDef def)
		{
			if (def == null)
			{
				return null;
			}
			EnsureScanned();
			if (Cache.TryGetValue(def.EffectId, out var value))
			{
				return value;
			}
			UnitEditorFootstepDebug.LogWarning("FootstepIconResolver: no unit icon for " + def.EffectId + " (" + def.AudioRef + ")");
			return null;
		}

		private static void EnsureScanned()
		{
			if (_scanned)
			{
				return;
			}
			_scanned = true;
			ContentDatabase val = ContentDatabase.Instance();
			if (val == null)
			{
				return;
			}
			IEnumerable<UnitBlueprint> allUnitBlueprints = val.GetAllUnitBlueprints();
			if (allUnitBlueprints == null)
			{
				return;
			}
			foreach (UnitBlueprint item in allUnitBlueprints)
			{
				if (((item != null) ? item.Entity : null) == null)
				{
					continue;
				}
				FootstepDef byAudioRef = FootstepCatalog.GetByAudioRef(FootstepBlueprintHelper.GetFootRef(item));
				if (!Cache.ContainsKey(byAudioRef.EffectId))
				{
					Sprite spriteIcon = item.Entity.SpriteIcon;
					if (!((Object)(object)spriteIcon == (Object)null))
					{
						Cache[byAudioRef.EffectId] = spriteIcon;
						UnitEditorFootstepDebug.Log("FootstepIconResolver: " + byAudioRef.EffectId + " <- " + item.Entity.Name);
					}
				}
			}
		}
	}
	internal static class FootstepMetadata
	{
		private const string TagPattern = "\\u200B?\\[\\[SCF:foot=([A-Za-z0-9]+)\\]\\]";

		private static readonly Regex TagRegex = new Regex("\\u200B?\\[\\[SCF:foot=([A-Za-z0-9]+)\\]\\]", RegexOptions.Compiled);

		internal static string Embed(string description, string effectId)
		{
			string text = Strip(description);
			if (string.IsNullOrEmpty(effectId) || string.Equals(effectId, "Normal", StringComparison.OrdinalIgnoreCase))
			{
				return text;
			}
			return text + "\u200b[[SCF:foot=" + effectId + "]]";
		}

		internal static string Strip(string description)
		{
			if (string.IsNullOrEmpty(description))
			{
				return string.Empty;
			}
			return TagRegex.Replace(description, string.Empty).TrimEnd(Array.Empty<char>());
		}

		internal static bool TryParse(string description, out string effectId, out string cleanDescription)
		{
			cleanDescription = Strip(description);
			effectId = null;
			if (string.IsNullOrEmpty(description))
			{
				return false;
			}
			Match match = TagRegex.Match(description);
			if (!match.Success)
			{
				return false;
			}
			effectId = match.Groups[1].Value;
			return !string.IsNullOrEmpty(effectId);
		}
	}
	internal static class FootstepRuntimePatches
	{
		public static void Validate_Postfix(UnitBlueprint __instance, ref bool __result)
		{
			if (UnitEditorConfig.CustomFootstepsEnabled && !((Object)(object)__instance == (Object)null))
			{
				float footPitch = FootstepBlueprintHelper.GetFootPitch(__instance);
				FootstepBlueprintHelper.ApplyPitchToPathData(__instance, footPitch);
			}
		}

		public static void Spawn_Postfix(UnitBlueprint __instance, Unit unitToSpawn)
		{
			if (UnitEditorConfig.CustomFootstepsEnabled && !((Object)(object)__instance == (Object)null) && !((Object)(object)unitToSpawn == (Object)null))
			{
				UnitSounds componentInChildren = ((Component)unitToSpawn).GetComponentInChildren<UnitSounds>();
				if (!((Object)(object)componentInChildren == (Object)null) && componentInChildren.FootPathData != null)
				{
					float footPitch = FootstepBlueprintHelper.GetFootPitch(__instance);
					componentInChildren.FootPathData.EffectPitch = ((footPitch <= 0f) ? 1f : footPitch);
				}
			}
		}

		public static bool PlayFootSound_Prefix(UnitSounds __instance, Vector3 collisionPoint, MaterialType materialType)
		{
			//IL_006a: 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)
			if (!UnitEditorConfig.CustomFootstepsEnabled || (Object)(object)__instance == (Object)null)
			{
				return true;
			}
			if (__instance.FootPathData == null || __instance.FootPathData.Effect == string.Empty)
			{
				return true;
			}
			float num = __instance.FootPathData.EffectPitch;
			if (num <= 0f)
			{
				num = 1f;
			}
			SoundPlayer service = ServiceLocator.GetService<SoundPlayer>();
			if ((Object)(object)service == (Object)null)
			{
				return true;
			}
			service.PlaySoundEffectNonAlloc(__instance.FootPathData, 1f, collisionPoint, materialType, (Transform)null, num);
			return false;
		}
	}
	internal static class GameStatePatches
	{
		public static void EnterBattleState_Postfix()
		{
			MirrorShieldLogic.ResetBattleState();
			WinConditionUiRefresh.RefreshObjectivesSidebars();
			BattleStateHelper.InvalidateCache();
			CustomEnemyTargetingSystem.InvalidateCaches();
		}

		public static void EnterPlacementState_Postfix()
		{
			TeamLineSquareCameraPatches.ForceUnblockSandboxCamera();
			StopCustomVoicesIfEnabled();
			BattleStateHelper.InvalidateCache();
			CustomEnemyTargetingSystem.InvalidateCaches();
		}

		public static void EnterNoneState_Postfix()
		{
			StopCustomVoicesIfEnabled();
			BattleStateHelper.InvalidateCache();
			CustomEnemyTargetingSystem.InvalidateCaches();
		}

		private static void StopCustomVoicesIfEnabled()
		{
			if (UnitEditorConfig.CustomVoicesEnabled)
			{
				CustomVoiceRuntime.StopAllActive();
			}
		}
	}
	internal static class MirrorProjectileCosts
	{
		[CompilerGenerated]
		private sealed class <GetNameSources>d__10 : IEnumerable<Transform>, IEnumerable, IEnumerator<Transform>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private Transform <>2__current;

			private int <>l__initialThreadId;

			private GameObject projectile;

			public GameObject <>3__projectile;

			private TeamHolder <teamHolder>5__2;

			private Transform <current>5__3;

			Transform IEnumerator<Transform>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetNameSources>d__10(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<teamHolder>5__2 = null;
				<current>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = projectile.transform;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<teamHolder>5__2 = projectile.GetComponent<TeamHolder>();
					if ((Object)(object)<teamHolder>5__2?.spawnerWeapon != (Object)null)
					{
						<>2__current = <teamHolder>5__2.spawnerWeapon.transform;
						<>1__state = 2;
						return true;
					}
					goto IL_009c;
				case 2:
					<>1__state = -1;
					goto IL_009c;
				case 3:
					<>1__state = -1;
					goto IL_00dc;
				case 4:
					{
						<>1__state = -1;
						<current>5__3 = <current>5__3.parent;
						break;
					}
					IL_00dc:
					<current>5__3 = projectile.transform.parent;
					break;
					IL_009c:
					if ((Object)(object)<teamHolder>5__2?.spawner != (Object)null)
					{
						<>2__current = <teamHolder>5__2.spawner.transform;
						<>1__state = 3;
						return true;
					}
					goto IL_00dc;
				}
				if ((Object)(object)<current>5__3 != (Object)null)
				{
					<>2__current = <current>5__3;
					<>1__state = 4;
					return true;
				}
				<current>5__3 = null;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Transform> IEnumerable<Transform>.GetEnumerator()
			{
				<GetNameSources>d__10 <GetNameSources>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetNameSources>d__ = this;
				}
				else
				{
					<GetNameSources>d__ = new <GetNameSources>d__10(0);
				}
				<GetNameSources>d__.projectile = <>3__projectile;
				return <GetNameSources>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Transform>)this).GetEnumerator();
			}
		}

		private static readonly int[] DeflectsAllowedByBlockPower = new int[4] { 12, 3, 2, 1 };

		internal static int GetReflectCost(GameObject projectile)
		{
			int deflectsAllowed = GetDeflectsAllowed(GetBlockPowerTier(projectile));
			return Mathf.Max(1, 12 / deflectsAllowed);
		}

		internal static int GetBlockPowerTier(GameObject projectile)
		{
			if (NameMatchesBallista(projectile))
			{
				return 3;
			}
			if (NameMatchesZeus(projectile))
			{
				return 2;
			}
			float rawBlockPoweredNeeded = GetRawBlockPoweredNeeded(projectile);
			if (rawBlockPoweredNeeded >= 2.5f)
			{
				return 3;
			}
			if (rawBlockPoweredNeeded >= 1.5f)
			{
				return 2;
			}
			if (rawBlockPoweredNeeded >= 0.5f)
			{
				return 1;
			}
			if (NameMatchesStandardArrow(projectile))
			{
				return 1;
			}
			return 0;
		}

		private static float GetRawBlockPoweredNeeded(GameObject projectile)
		{
			if ((Object)(object)projectile == (Object)null)
			{
				return 1f;
			}
			ProjectileHit component = projectile.GetComponent<ProjectileHit>();
			if (!((Object)(object)component != (Object)null))
			{
				return 1f;
			}
			return component.blockPoweredNeeded;
		}

		private static int GetDeflectsAllowed(int blockPower)
		{
			if (blockPower < DeflectsAllowedByBlockPower.Length)
			{
				return DeflectsAllowedByBlockPower[blockPower];
			}
			return 1;
		}

		private static bool NameMatchesStandardArrow(GameObject projectile)
		{
			if (NameMatchesBlowdart(projectile))
			{
				return false;
			}
			return NameMatchesAny(projectile, "P_Bow", "Crossbow", "Arrow");
		}

		private static bool NameMatchesBlowdart(GameObject projectile)
		{
			return NameMatchesAny(projectile, "Blowdart", "BlowDart", "p_Blowdart");
		}

		private static bool NameMatchesBallista(GameObject projectile)
		{
			foreach (Transform nameSource in GetNameSources(projectile))
			{
				if (!((Object)(object)nameSource == (Object)null))
				{
					string name = ((Object)nameSource).name;
					if (name.IndexOf("P_Ballista", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
					if (name.IndexOf("BallistaArrow", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
					if (name.IndexOf("Ballista", StringComparison.OrdinalIgnoreCase) >= 0 && name.IndexOf("Bolt", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool NameMatchesZeus(GameObject projectile)
		{
			if ((Object)(object)projectile.GetComponent<ChainLightning>() != (Object)null)
			{
				return true;
			}
			foreach (Transform nameSource in GetNameSources(projectile))
			{
				if ((Object)(object)nameSource == (Object)null)
				{
					continue;
				}
				string name = ((Object)nameSource).name;
				if (name.IndexOf("LightningBow", StringComparison.OrdinalIgnoreCase) < 0)
				{
					if (name.IndexOf("P_Zeus", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
					if (name.IndexOf("Zeus", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool NameMatchesAny(GameObject projectile, params string[] needles)
		{
			foreach (Transform nameSource in GetNameSources(projectile))
			{
				if ((Object)(object)nameSource == (Object)null)
				{
					continue;
				}
				string name = ((Object)nameSource).name;
				for (int i = 0; i < needles.Length; i++)
				{
					if (name.IndexOf(needles[i], StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
			}
			return false;
		}

		[IteratorStateMachine(typeof(<GetNameSources>d__10))]
		private static IEnumerable<Transform> GetNameSources(GameObject projectile)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetNameSources>d__10(-2)
			{
				<>3__projectile = projectile
			};
		}
	}
	internal static class MirrorShieldAudio
	{
		[CompilerGenerated]
		private sealed class <PlayBreakNextFrame>d__3 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Transform weaponRoot;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <PlayBreakNextFrame>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)weaponRoot != (Object)null)
					{
						PlayBreakImmediate(weaponRoot);
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private const string BreakSoundRef = "Effects/IceArrowEffect";

		private const float BreakSoundVolume = 1.25f;

		internal static void PlayBreak(Transform weaponRoot)
		{
			if (MirrorShieldConfig.Improved && !((Object)(object)weaponRoot == (Object)null))
			{
				if ((Object)(object)Plugin.Instance != (Object)null)
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(PlayBreakNextFrame(weaponRoot));
				}
				else
				{
					PlayBreakImmediate(weaponRoot);
				}
			}
		}

		[IteratorStateMachine(typeof(<PlayBreakNextFrame>d__3))]
		private static IEnumerator PlayBreakNextFrame(Transform weaponRoot)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayBreakNextFrame>d__3(0)
			{
				weaponRoot = weaponRoot
			};
		}

		private static void PlayBreakImmediate(Transform weaponRoot)
		{
			//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_0051: 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)
			SoundPlayer service = ServiceLocator.GetService<SoundPlayer>();
			if (!((Object)(object)service == (Object)null))
			{
				Vector3 val = ResolveSoundPosition(weaponRoot);
				AudioPathData val2 = null;
				if (AudioPathData.ValidateAndAssignPathData("Effects/IceArrowEffect", ref val2, (Object)(object)((Component)weaponRoot).gameObject) && val2 != null)
				{
					service.PlaySoundEffectNonAlloc(val2, 1.25f, val, (MaterialType)0, weaponRoot, 1f);
				}
				else
				{
					service.PlaySoundEffect("Effects/IceArrowEffect", 1.25f, val, (MaterialType)0, weaponRoot, 1f);
				}
			}
		}

		private static Vector3 ResolveSoundPosition(Transform weaponRoot)
		{
			//IL_0017: 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_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_0036: Unknown result type (might be due to invalid IL or missing references)
			SurfaceReflect componentInChildren = ((Component)weaponRoot).GetComponentInChildren<SurfaceReflect>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				return ((Component)componentInChildren).transform.position;
			}
			Renderer componentInChildren2 = ((Component)weaponRoot).GetComponentInChildren<Renderer>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				Bounds bounds = componentInChildren2.bounds;
				return ((Bounds)(ref bounds)).center;
			}
			return weaponRoot.position;
		}
	}
	internal static class MirrorShieldConfig
	{
		internal static bool Improved = true;

		private static readonly ConfigDefinition[] OrphanedKeys = (ConfigDefinition[])(object)new ConfigDefinition[6]
		{
			new ConfigDefinition("Mirror.Shield", "Enabled"),
			new ConfigDefinition("Mirror.Shield", "BreakSoundEnabled"),
			new ConfigDefinition("Mirror.Shield", "BreakSoundMode"),
			new ConfigDefinition("Mirror.Shield", "VanillaBreakSoundRef"),
			new ConfigDefinition("Mirror.Shield", "CustomBreakSoundFile"),
			new ConfigDefinition("Mirror.Shield", "BreakSoundVolume")
		};

		internal static void Bind(ConfigFile config)
		{
			ConfigDefinition[] orphanedKeys = OrphanedKeys;
			foreach (ConfigDefinition val in orphanedKeys)
			{
				config.Remove(val);
			}
			Improved = config.Bind<bool>("Mirror.Shield", "Improved", true, "Improved mirror shield (true) or vanilla mirror shield (false).").Value;
		}
	}
	internal static class MirrorShieldLogic
	{
		[CompilerGenerated]
		private sealed class <EnforceReflectVelocityRoutine>d__26 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject projectile;

			public Vector3 velocity;

			private int <i>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EnforceReflectVelocityRoutine>d__26(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<i>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < 4)
				{
					if ((Object)(object)projectile == (Object)null)
					{
						return false;
					}
					MoveTransform component = projectile.GetComponent<MoveTransform>();
					if ((Object)(object)component != (Object)null && ((Vector3)(ref component.velocity)).sqrMagnitude < ((Vector3)(ref velocity)).sqrMagnitude * 0.25f)
					{
						component.velocity = velocity;
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		internal const int MaxReflects = 12;

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

		private static readonly HashSet<int> HandledProjectileIdsThisFrame = new HashSet<int>();

		private static readonly FieldInfo CurrentProjectilesPerBlockField = typeof(BlockMove).GetField("currentProjectilesPerBlock", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo BlockMoveDataField = typeof(BlockMove).GetField("data", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo ProjectileHitCounterField = typeof(ProjectileHit).GetField("counter", BindingFlags.Instance | BindingFlags.NonPublic);

		private static int _handledProjectileFrame = -1;

		internal static void ResetBattleState()
		{
			RemainingReflectsByWeaponKey.Clear();
			HandledProjectileIdsThisFrame.Clear();
			MirrorShieldVfx.ResetBattleState();
			_handledProjectileFrame = -1;
		}

		internal static bool IsMirrorWeapon(Transform transform)
		{
			if (!MirrorShieldConfig.Improved || (Object)(object)transform == (Object)null)
			{
				return false;
			}
			Holdable componentInParent = ((Component)transform).GetComponentInParent<Holdable>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				if ((Object)(object)((Component)componentInParent).GetComponentInChildren<ShieldWobble>(true) != (Object)null)
				{
					return true;
				}
				Transform[] componentsInChildren = ((Component)componentInParent).GetComponentsInChildren<Transform>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if (((Object)componentsInChildren[i]).name.IndexOf("Mirror", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
			}
			if ((Object)(object)((Component)transform).GetComponentInParent<ShieldWobble>() != (Object)null)
			{
				return true;
			}
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				if (((Object)val).name.IndexOf("Mirror", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		internal static bool TryInterceptProjectileHit(Transform hitTransform, GameObject projectile, HitData hit)
		{
			if (!MirrorShieldConfig.Improved || (Object)(object)hitTransform == (Object)null || (Object)(object)projectile == (Object)null || !IsMirrorWeapon(hitTransform))
			{
				return false;
			}
			Transform mirrorWeaponRoot = GetMirrorWeaponRoot(hitTransform);
			if (!HasReflectsRemaining(mirrorWeaponRoot))
			{
				return false;
			}
			BlockMove block = ResolveBlockMoveFromHit(hitTransform);
			if (ShouldSkipMirrorReflect(projectile, hitTransform, block) || !CanAffordReflect(mirrorWeaponRoot, projectile))
			{
				return false;
			}
			ProcessMirrorHit(mirrorWeaponRoot, block, projectile, hit);
			return true;
		}

		internal static void ApplyMirrorSurfaceResult(Transform owner, BlockMove block, GameObject projectile, HitData hit, out bool surfaceHandled)
		{
			surfaceHandled = false;
			if (MirrorShieldConfig.Improved)
			{
				Transform mirrorWeaponRoot = GetMirrorWeaponRoot(owner);
				if (HasReflectsRemaining(mirrorWeaponRoot) && !ShouldSkipMirrorReflect(projectile, owner, block) && CanAffordReflect(mirrorWeaponRoot, projectile))
				{
					ProcessMirrorHit(mirrorWeaponRoot, block, projectile, hit);
					surfaceHandled = true;
				}
			}
		}

		internal static bool CanAffordReflect(Transform weaponRoot, GameObject projectile)
		{
			return GetRemainingReflects(weaponRoot) >= MirrorProjectileCosts.GetReflectCost(projectile);
		}

		internal static bool HasReflectsRemaining(Transform transform)
		{
			if (IsMirrorWeapon(transform))
			{
				return GetRemainingReflects(transform) > 0;
			}
			return true;
		}

		internal static bool ShouldBlockDisable(BlockMove block)
		{
			if ((Object)(object)block != (Object)null && IsMirrorWeapon(((Component)block).transform))
			{
				return HasReflectsRemaining(GetMirrorWeaponRoot(((Component)block).transform));
			}
			return false;
		}

		internal static bool WasProjectileHandledThisFrame(GameObject projectile)
		{
			return WasAlreadyHandledThisFrame(projectile);
		}

		internal static BlockMove ResolveBlockMove(Component surfaceComponent)
		{
			if ((Object)(object)surfaceComponent == (Object)null)
			{
				return null;
			}
			SurfaceBlock val = (SurfaceBlock)(object)((surfaceComponent is SurfaceBlock) ? surfaceComponent : null);
			if (val != null && (Object)(object)val.blockMove != (Object)null)
			{
				return val.blockMove;
			}
			return surfaceComponent.GetComponentInParent<BlockMove>() ?? surfaceComponent.GetComponentInChildren<BlockMove>();
		}

		private static void ProcessMirrorHit(Transform weaponRoot, BlockMove block, GameObject projectile, HitData hit)
		{
			TryInitialize(weaponRoot);
			if (WasAlreadyHandledThisFrame(projectile))
			{
				return;
			}
			if ((Object)(object)block != (Object)null && !block.isActive)
			{
				block.SetEnabled();
			}
			if (!ShouldSkipMirrorReflect(projectile, weaponRoot, block))
			{
				int reflectCost = MirrorProjectileCosts.GetReflectCost(projectile);
				if (GetRemainingReflects(weaponRoot) >= reflectCost)
				{
					MarkHandledThisFrame(projectile);
					ReflectAndSpendCharge(weaponRoot, block, projectile, hit, reflectCost);
				}
			}
		}

		private static void TryInitialize(Transform weaponRoot)
		{
			int weaponKey = GetWeaponKey(weaponRoot);
			if (!RemainingReflectsByWeaponKey.ContainsKey(weaponKey))
			{
				RemainingReflectsByWeaponKey[weaponKey] = 12;
				SyncVanillaBlockCounters(weaponRoot);
				MirrorShieldVfx.Bind(weaponRoot);
			}
		}

		private static void SyncVanillaBlockCounters(Transform weaponRoot)
		{
			SurfaceReflect[] componentsInParent = ((Component)weaponRoot).GetComponentsInParent<SurfaceReflect>(true);
			foreach (SurfaceReflect val in componentsInParent)
			{
				if (IsMirrorWeapon(((Component)val).transform))
				{
					((Behaviour)val).enabled = true;
				}
			}
			BlockMove[] componentsInParent2 = ((Component)weaponRoot).GetComponentsInParent<BlockMove>(true);
			foreach (BlockMove val2 in componentsInParent2)
			{
				if (IsMirrorWeapon(((Component)val2).transform))
				{
					val2.projectilesPerBlock = 12;
					val2.blockPower = 12f;
					CurrentProjectilesPerBlockField?.SetValue(val2, 12);
					if (!val2.isActive)
					{
						val2.SetEnabled();
					}
					Counter component = ((Component)val2).GetComponent<Counter>();
					if ((Object)(object)component != (Object)null)
					{
						component.cooldown = 0f;
					}
				}
			}
		}

		private static void ReflectAndSpendCharge(Transform weaponRoot, BlockMove block, GameObject projectile, HitData hit, int cost)
		{
			ApplyReflect(weaponRoot, block, projectile, hit);
			PlayHitFeedback(weaponRoot, hit);
			SpendReflectCharge(weaponRoot, cost);
		}

		private static void PlayHitFeedback(Transform weaponRoot, HitData hit)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			ShieldWobble componentInParent = ((Component)weaponRoot).GetComponentInParent<ShieldWobble>();
			if ((Object)(object)componentInParent != (Object)null)
			{
				componentInParent.OnHit(hit.point);
			}
			MirrorShieldVfx.PlayBlockHit(weaponRoot, hit);
		}

		private static void ApplyReflect(Transform weaponRoot, BlockMove block, GameObject projectile, HitData hit)
		{
			//IL_00b9: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			MoveTransform component = projectile.GetComponent<MoveTransform>();
			if (!((Object)(object)component == (Object)null))
			{
				if ((Object)(object)((Component)weaponRoot).GetComponentInChildren<SurfaceReflect>(true) != (Object)null)
				{
					FlipVelocity(component);
				}
				else if ((Object)(object)block != (Object)null && block.reflect)
				{
					ReflectOffBlock(block, component, hit);
				}
				else
				{
					FlipVelocity(component);
				}
				ApplyTeamAfterReflect(block, projectile, weaponRoot);
				ProjectileHit component2 = projectile.GetComponent<ProjectileHit>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.canHitOrgUnit = true;
				}
				RaycastTrail component3 = projectile.GetComponent<RaycastTrail>();
				if ((Object)(object)component3 != (Object)null)
				{
					component3.ignoredFrames = 5;
				}
				if (((Vector3)(ref hit.normal)).sqrMagnitude > 0.0001f)
				{
					projectile.transform.position = hit.point + hit.normal * 0.15f;
				}
				EnforceReflectVelocity(projectile, component.velocity);
			}
		}

		private static void FlipVelocity(MoveTransform moveTransform)
		{
			//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_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_0014: 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)
			if (((Vector3)(ref moveTransform.velocity)).sqrMagnitude > 0.0001f)
			{
				moveTransform.velocity *= -1f;
			}
			else
			{
				moveTransform.velocity = -((Component)moveTransform).transform.forward * 15f;
			}
		}

		private static void ReflectOffBlock(BlockMove block, MoveTransform moveTransform, HitData hit)
		{
			//IL_001a: 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_001f: 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_0034: 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_003f: 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_0065: 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_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)
			Vector3 val = ((((Vector3)(ref hit.normal)).sqrMagnitude > 0.0001f) ? hit.normal : Vector3.up);
			if (((Vector3)(ref moveTransform.velocity)).sqrMagnitude > 0.0001f)
			{
				moveTransform.velocity = Vector3.Reflect(moveTransform.velocity, val);
				return;
			}
			Vector3 forward = ((Component)moveTransform).transform.forward;
			Vector3 val2 = ((((Vector3)(ref forward)).sqrMagnitude > 0.0001f) ? ((Component)moveTransform).transform.forward : ((Component)block).transform.forward);
			moveTransform.velocity = -((Vector3)(ref val2)).normalized * 15f;
		}

		private static void ApplyTeamAfterReflect(BlockMove block, GameObject projectile, Transform weaponRoot)
		{
			//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)
			TeamHolder component = projectile.GetComponent<TeamHolder>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			if ((Object)(object)block != (Object)null && block.switchTeam)
			{
				DataHandler componentInChildren = ((Component)weaponRoot.root).GetComponentInChildren<DataHandler>();
				if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.unit != (Object)null)
				{
					component.team = componentInChildren.unit.Team;
				}
			}
			else
			{
				component.SwitchTeam();
			}
		}

		private static void EnforceReflectVelocity(GameObject projectile, Vector3 velocity)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Plugin.Instance == (Object)null) && !(((Vector3)(ref velocity)).sqrMagnitude < 0.01f))
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(EnforceReflectVelocityRoutine(projectile, velocity));
			}
		}

		[IteratorStateMachine(typeof(<EnforceReflectVelocityRoutine>d__26))]
		private static IEnumerator EnforceReflectVelocityRoutine(GameObject projectile, Vector3 velocity)
		{
			//IL_000e: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnforceReflectVelocityRoutine>d__26(0)
			{
				projectile = projectile,
				velocity = velocity
			};
		}

		private static void SpendReflectCharge(Transform weaponRoot, int cost)
		{
			int weaponKey = GetWeaponKey(weaponRoot);
			RemainingReflectsByWeaponKey[weaponKey] = Mathf.Max(0, GetRemainingReflects(weaponRoot) - Mathf.Max(1, cost));
			if (GetRemainingReflects(weaponRoot) <= 0)
			{
				MirrorShieldAudio.PlayBreak(weaponRoot);
			}
		}

		internal static bool ShouldSkipMirrorReflect(GameObject projectile, Transform hitOnMirror, BlockMove block = null)
		{
			//IL_0065: 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)
			if ((Object)(object)projectile == (Object)null || (Object)(object)hitOnMirror == (Object)null)
			{
				return false;
			}
			TeamHolder component = projectile.GetComponent<TeamHolder>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			GameObject gameObject = ((Component)hitOnMirror.root).gameObject;
			if ((Object)(object)component.spawner != (Object)null && (Object)(object)component.spawner == (Object)(object)gameObject)
			{
				return true;
			}
			Team? defenderTeam = GetDefenderTeam(hitOnMirror, block);
			if (!defenderTeam.HasValue)
			{
				return false;
			}
			return defenderTeam.Value == component.team;
		}

		internal static bool ProjectileHitWouldIgnoreTeamMate(ProjectileHit projectileHit, HitData hit)
		{
			//IL_00c6: 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)
			if ((Object)(object)projectileHit == (Object)null || (Object)(object)hit.transform == (Object)null)
			{
				return false;
			}
			TeamHolder component = ((Component)projectileHit).GetComponent<TeamHolder>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			if ((Object)(object)component.spawner != (Object)null && (Object)(object)((Component)hit.transform.root).gameObject == (Object)(object)component.spawner && !projectileHit.canHitOrgUnit)
			{
				return true;
			}
			Unit component2 = ((Component)hit.transform.root).GetComponent<Unit>();
			MoveTransform component3 = ((Component)projectileHit).GetComponent<MoveTransform>();
			if ((Object)(object)component2 == (Object)null || (Object)(object)component3 == (Object)null)
			{
				return false;
			}
			bool flag = false;
			if (ProjectileHitCounterField != null)
			{
				flag = (float)ProjectileHitCounterField.GetValue(projectileHit) * 0.01f * ((Vector3)(ref component3.velocity)).magnitude < 0.1f;
			}
			if (component.team == component2.Team && (flag || projectileHit.ignoreTeamMates))
			{
				return !projectileHit.alwaysHitTeamMates;
			}
			return false;
		}

		private static Team? GetDefenderTeam(Transform hitOnMirror, BlockMove block)
		{
			//IL_0065: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)block != (Object)null && BlockMoveDataField != null)
			{
				object? value = BlockMoveDataField.GetValue(block);
				DataHandler val = (DataHandler)((value is DataHandler) ? value : null);
				if ((Object)(object)val != (Object)null && (Object)(object)val.unit != (Object)null)
				{
					return val.unit.Team;
				}
			}
			Unit component = ((Component)hitOnMirror.root).GetComponent<Unit>();
			if ((Object)(object)component != (Object)null)
			{
				return component.Team;
			}
			DataHandler componentInParent = ((Component)hitOnMirror).GetComponentInParent<DataHandler>();
			if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.unit != (Object)null)
			{
				return componentInParent.unit.Team;
			}
			return null;
		}

		internal static BlockMove ResolveBlockMoveFromHit(Transform hitTransform)
		{
			return ((Component)hitTransform).GetComponentInParent<BlockMove>();
		}

		internal static Transform GetMirrorWeaponRoot(Transform hitTransform)
		{
			Holdable componentInParent = ((Component)hitTransform).GetComponentInParent<Holdable>();
			if (!((Object)(object)componentInParent != (Object)null))
			{
				return hitTransform.root;
			}
			return ((Component)componentInParent).transform;
		}

		private static bool WasAlreadyHandledThisFrame(GameObject projectile)
		{
			if (_handledProjectileFrame != Time.frameCount)
			{
				_handledProjectileFrame = Time.frameCount;
				HandledProjectileIdsThisFrame.Clear();
			}
			return HandledProjectileIdsThisFrame.Contains(((Object)projectile).GetInstanceID());
		}

		private static void MarkHandledThisFrame(GameObject projectile)
		{
			if (_handledProjectileFrame != Time.frameCount)
			{
				_handledProjectileFrame = Time.frameCount;
				HandledProjectileIdsThisFrame.Clear();
			}
			HandledProjectileIdsThisFrame.Add(((Object)projectile).GetInstanceID());
		}

		private static int GetRemainingReflects(Transform transform)
		{
			Transform mirrorWeaponRoot = GetMirrorWeaponRoot(transform);
			int weaponKey = GetWeaponKey(mirrorWeaponRoot);
			if (RemainingReflectsByWeaponKey.TryGetValue(weaponKey, out var value))
			{
				return value;
			}
			TryInitialize(mirrorWeaponRoot);
			return 12;
		}

		private static int GetWeaponKey(Transform transform)
		{
			return ((Object)GetMirrorWeaponRoot(transform)).GetInstanceID();
		}
	}
	internal static class MirrorShieldPatches
	{
		private static bool PassThrough => !MirrorShieldConfig.Improved;

		public static bool ProjectileHit_Hit_Prefix(ProjectileHit __instance, RaycastHit sentHit, float multiplier)
		{
			//IL_005c: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			if (PassThrough || __instance.done)
			{
				return true;
			}
			Transform val = (((Object)(object)((RaycastHit)(ref sentHit)).rigidbody != (Object)null) ? ((Component)((RaycastHit)(ref sentHit)).rigidbody).transform : ((Component)((RaycastHit)(ref sentHit)).collider).transform);
			if (!MirrorShieldLogic.IsMirrorWeapon(val))
			{
				return true;
			}
			HitData hit = new HitData(((RaycastHit)(ref sentHit)).transform, ((RaycastHit)(ref sentHit)).rigidbody, ((RaycastHit)(ref sentHit)).collider, ((RaycastHit)(ref sentHit)).normal, ((RaycastHit)(ref sentHit)).point, ((RaycastHit)(ref sentHit)).distance);
			BlockMove block = MirrorShieldLogic.ResolveBlockMoveFromHit(val);
			if (MirrorShieldLogic.ShouldSkipMirrorReflect(((Component)__instance).gameObject, val, block) || MirrorShieldLogic.ProjectileHitWouldIgnoreTeamMate(__instance, hit))
			{
				return true;
			}
			return !MirrorShieldLogic.TryInterceptProjectileHit(val, ((Component)__instance).gameObject, hit);
		}

		public static bool SurfaceBlock_DoEffect_Prefix(SurfaceBlock __instance, HitData hit, GameObject projectile, ref bool __result)
		{
			if (PassThrough || !MirrorShieldLogic.IsMirrorWeapon(((Component)__instance).transform))
			{
				return true;
			}
			BlockMove val = MirrorShieldLogic.ResolveBlockMove((Component)(object)__instance);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			if (MirrorShieldLogic.ShouldSkipMirrorReflect(projectile, ((Component)__instance).transform, val))
			{
				__result = true;
				return false;
			}
			MirrorShieldLogic.ApplyMirrorSurfaceResult(((Component)__instance).transform, val, projectile, hit, out __result);
			return false;
		}

		public static bool SurfaceReflect_DoEffect_Prefix(SurfaceReflect __instance, HitData hit, GameObject projectile, ref bool __result)
		{
			if (PassThrough || !MirrorShieldLogic.IsMirrorWeapon(((Component)__instance).transform))
			{
				return true;
			}
			BlockMove block = MirrorShieldLogic.ResolveBlockMove((Component)(object)__instance);
			if (MirrorShieldLogic.ShouldSkipMirrorReflect(projectile, ((Component)__instance).transform, block))
			{
				__result = true;
				return false;
			}
			MirrorShieldLogic.ApplyMirrorSurfaceResult(((Component)__instance).transform, block, projectile, hit, out __result);
			return false;
		}

		public static bool BlockMove_ProjectileBlock_Prefix(BlockMove __instance, GameObject projectile, HitData hit, ref bool __result)
		{
			if (PassThrough || !MirrorShieldLogic.IsMirrorWeapon(((Component)__instance).transform))
			{
				return true;
			}
			if (MirrorShieldLogic.ShouldSkipMirrorReflect(projectile, ((Component)__instance).transform, __instance))
			{
				return true;
			}
			if (!MirrorShieldLogic.HasReflectsRemaining(((Component)__instance).transform))
			{
				return true;
			}
			MirrorShieldLogic.ApplyMirrorSurfaceResult(((Component)__instance).transform, __instance, projectile, hit, out __result);
			return false;
		}

		public static bool BlockMove_SetDisabled_Prefix(BlockMove __instance)
		{
			if (PassThrough)
			{
				return true;
			}
			return !MirrorShieldLogic.ShouldBlockDisable(__instance);
		}

		public static bool BlockMoveHealth_DoBlock_Prefix(BlockMoveHealth __instance)
		{
			if (PassThrough)
			{
				return true;
			}
			return !MirrorShieldLogic.IsMirrorWeapon(((Component)__instance).transform);
		}

		public static bool Charges_UseCharge_Prefix(Charges __instance)
		{
			if (PassThrough)
			{
				return true;
			}
			return !MirrorShieldLogic.IsMirrorWeapon(((Component)__instance).transform);
		}

		public static void RaycastTrail_Check_Prefix(RaycastTrail __instance)
		{
			if (!PassThrough)
			{
				MirrorShieldSweep.TrySweepAhead(__instance);
			}
		}
	}
	internal static class MirrorShieldSweep
	{
		private const float MinCastRadius = 0.07f;

		private const float SpeedRadiusScale = 0.4f;

		private const float SpeedDistanceScale = 2f;

		private const float MinExtraCastDistance = 0.35f;

		private static readonly FieldInfo RaycastTrailLastPosField = typeof(RaycastTrail).GetField("lastPos", BindingFlags.Instance | BindingFlags.NonPublic);

		internal static void TrySweepAhead(RaycastTrail trail)
		{
			//IL_005b: 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_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_00ba: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: 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_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: 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_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Expected O, but got Unknown
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: 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_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: 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)
			if (!MirrorShieldConfig.Improved || (Object)(object)trail == (Object)null || trail.ignoredFrames > 0 || RaycastTrailLastPosField == null)
			{
				return;
			}
			ProjectileHit component = ((Component)trail).GetComponent<ProjectileHit>();
			if ((Object)(object)component == (Object)null || component.done)
			{
				return;
			}
			GameObject gameObject = ((Component)component).gameObject;
			if (MirrorShieldLogic.WasProjectileHandledThisFrame(gameObject))
			{
				return;
			}
			Vector3 val = (Vector3)RaycastTrailLastPosField.GetValue(trail);
			Vector3 val2 = ((Component)trail).transform.position - val;
			float magnitude = ((Vector3)(ref val2)).magnitude;
			if (magnitude < 0.0001f)
			{
				return;
			}
			MoveTransform component2 = gameObject.GetComponent<MoveTransform>();
			float num = (((Object)(object)component2 != (Object)null) ? ((Vector3)(ref component2.velocity)).magnitude : (magnitude / Mathf.Max(Time.deltaTime, 0.001f)));
			Vector3 val3 = val2 / magnitude;
			float num2 = (trail.useSphereCastOnUnits ? (Mathf.Max(trail.radius, 0.07f) + num * Time.deltaTime * 0.4f) : (0.07f + num * Time.deltaTime * 0.4f * 0.5f));
			float num3 = magnitude + num * Time.deltaTime * 2f + num2 + 0.35f;
			RaycastHit[] array = Physics.SphereCastAll(val, num2, val3, num3, LayerMask.op_Implicit(trail.mask), (QueryTriggerInteraction)1);
			if (array == null || array.Length == 0)
			{
				return;
			}
			RaycastHit? val4 = null;
			float num4 = float.MaxValue;
			RaycastHit[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RaycastHit value = array2[i];
				if (!((Object)(object)((RaycastHit)(ref value)).collider == (Object)null) && MirrorShieldLogic.IsMirrorWeapon(((Component)((RaycastHit)(ref value)).collider).transform))
				{
					Transform mirrorWeaponRoot = MirrorShieldLogic.GetMirrorWeaponRoot(((Component)((RaycastHit)(ref value)).collider).transform);
					BlockMove block = MirrorShieldLogic.ResolveBlockMoveFromHit(((Component)((RaycastHit)(ref value)).collider).transform);
					if (MirrorShieldLogic.HasReflectsRemaining(mirrorWeaponRoot) && !MirrorShieldLogic.ShouldSkipMirrorReflect(gameObject, ((Component)((RaycastHit)(ref value)).collider).transform, block) && !(((RaycastHit)(ref value)).distance >= num4))
					{
						num4 = ((RaycastHit)(ref value)).distance;
						val4 = value;
					}
				}
			}
			if (val4.HasValue)
			{
				RaycastHit value2 = val4.Value;
				HitData hit = new HitData(((RaycastHit)(ref value2)).transform, ((RaycastHit)(ref value2)).rigidbody, ((RaycastHit)(ref value2)).collider, ((RaycastHit)(ref value2)).normal, ((RaycastHit)(ref value2)).point, ((RaycastHit)(ref value2)).distance);
				if (MirrorShieldLogic.TryInterceptProjectileHit(((Component)((RaycastHit)(ref value2)).collider).transform, gameObject, hit))
				{
					Vector3 val5 = ((RaycastHit)(ref value2)).point + ((RaycastHit)(ref value2)).normal * 0.15f;
					((Component)trail).transform.position = val5;
					RaycastTrailLastPosField.SetValue(trail, val5);
				}
			}
		}
	}
	internal static class MirrorShieldVfx
	{
		private sealed class WeaponVfx
		{
			internal ParticleSystem[] HitParticles = Array.Empty<ParticleSystem>();

			internal SurfaceReflect SurfaceReflect;
		}

		private const int HitEmitCount = 10;

		private const float ReflectPartForwardOffset = 0.4f;

		private static readonly Dictionary<int, WeaponVfx> CacheByWeaponKey = new Dictionary<int, WeaponVfx>();

		internal static void ResetBattleState()
		{
			CacheByWeaponKey.Clear();
		}

		internal static void Bind(Transform weaponRoot)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)weaponRoot == (Object)null || !MirrorShieldLogic.IsMirrorWeapon(weaponRoot))
			{
				return;
			}
			int instanceID = ((Object)weaponRoot).GetInstanceID();
			if (CacheByWeaponKey.ContainsKey(instanceID))
			{
				return;
			}
			SurfaceReflect componentInChildren = ((Component)weaponRoot).GetComponentInChildren<SurfaceReflect>(true);
			ParticleSystem val = (((Object)(object)componentInChildren != (Object)null) ? componentInChildren.part : null);
			List<ParticleSystem> list = new List<ParticleSystem>();
			ParticleSystem[] componentsInChildren = ((Component)weaponRoot).GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				if ((Object)(object)val != (Object)null && (Object)(object)val2 == (Object)(object)val)
				{
					list.Add(val2);
					continue;
				}
				MainModule main = val2.main;
				if (!((MainModule)(ref main)).loop)
				{
					list.Add(val2);
				}
			}
			if ((Object)(object)val != (Object)null && !list.Contains(val))
			{
				list.Add(val);
			}
			CacheByWeaponKey[instanceID] = new WeaponVfx
			{
				SurfaceReflect = componentInChildren,
				HitParticles = list.ToArray()
			};
		}

		internal static void PlayBlockHit(Transform weaponRoot, HitData hit)
		{
			//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_003f: 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_0055: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			if (!MirrorShieldConfig.Improved || (Object)(object)weaponRoot == (Object)null)
			{
				return;
			}
			WeaponVfx orBind = GetOrBind(weaponRoot);
			Transform reflectTransform = (((Object)(object)orBind.SurfaceReflect != (Object)null) ? ((Component)orBind.SurfaceReflect).transform : null);
			Vector3 position = ResolveEmitPosition(hit, reflectTransform);
			EmitParams val = default(EmitParams);
			((EmitParams)(ref val)).position = position;
			((EmitParams)(ref val)).applyShapeToPosition = true;
			EmitParams val2 = val;
			ParticleSystem[] hitParticles = orBind.HitParticles;
			foreach (ParticleSystem val3 in hitParticles)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					val3.Emit(val2, 10);
				}
			}
		}

		private static WeaponVfx GetOrBind(Transform weaponRoot)
		{
			int instanceID = ((Object)weaponRoot).GetInstanceID();
			if (!CacheByWeaponKey.TryGetValue(instanceID, out var value))
			{
				Bind(weaponRoot);
				CacheByWeaponKey.TryGetValue(instanceID, out value);
			}
			return value;
		}

		private static Vector3 ResolveEmitPosition(HitData hit, Transform reflectTransform)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0054: 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_003e: 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)
			if ((Object)(object)reflectTransform != (Object)null)
			{
				return hit.point + reflectTransform.forward * 0.4f;
			}
			if (((Vector3)(ref hit.normal)).sqrMagnitude > 0.0001f)
			{
				return hit.point + hit.normal * 0.15f;
			}
			return hit.point;
		}
	}
	internal static class ModInfo
	{
		public const string Author = "Pretz";

		public const string PluginGuid = "pretz.tabsunlimited";

		public const string PluginName = "TABS Unlimited";

		public const string Version = "1.0.0";
	}
	internal static class MoveWhileTurningHelper
	{
		private static readonly Dictionary<int, bool> ExplicitByBlueprintId = new Dictionary<int, bool>();

		internal static bool IsNeverStopRunningMovement(IReadOnlyList<IMovementComponent> movementComponents)
		{
			if (movementComponents == null)
			{
				return false;
			}
			for (int i = 0; i < movementComponents.Count; i++)
			{
				if (movementComponents[i] is NeverStopRunning)
				{
					return true;
				}
			}
			return false;
		}

		internal static bool TryGetExplicit(UnitBlueprint blueprint, out bool enabled)
		{
			enabled = false;
			if ((Object)(object)blueprint == (Object)null)
			{
				return false;
			}
			return ExplicitByBlueprintId.TryGetValue(GetBlueprintId(blueprint), out enabled);
		}

		internal static void SetExplicit(UnitBlueprint blueprint, bool enabled)
		{
			if (!((Object)(object)blueprint == (Object)null))
			{
				ExplicitByBlueprintId[GetBlueprintId(blueprint)] = enabled;
			}
		}

		internal static void ClearExplicit(UnitBlueprint blueprint)
		{
			if (!((Object)(object)blueprint == (Object)null))
			{
				ExplicitByBlueprintId.Remove(GetBlueprintId(blueprint));
			}
		}

		internal static bool ShouldMoveWhileTurning(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null)
			{
				return false;
			}
			if (TryGetExplicit(blueprint, out var enabled))
			{
				return enabled;
			}
			return IsNeverStopRunningMovement(blueprint.MovementComponents);
		}

		internal static bool ResolveForSave(UnitBlueprint blueprint, bool editorEnabled, bool explicitlySet)
		{
			if (explicitlySet)
			{
				return editorEnabled;
			}
			return ShouldMoveWhileTurning(blueprint);
		}

		internal static void ApplyFromSerializedDescription(UnitBlueprint blueprint, string description)
		{
			if (!((Object)(object)blueprint == (Object)null))
			{
				if (MoveWhileTurningMetadata.TryParse(description, out var enabled, out var _))
				{
					SetExplicit(blueprint, enabled);
				}
				else
				{
					ClearExplicit(blueprint);
				}
			}
		}

		internal static void ApplyToUnit(Unit unit, UnitBlueprint blueprint = null)
		{
			if ((Object)(object)unit == (Object)null)
			{
				return;
			}
			if (blueprint == null)
			{
				blueprint = unit.unitBlueprint;
			}
			if (!((Object)(object)blueprint == (Object)null))
			{
				MovementHandler componentInChildren = ((Component)unit).GetComponentInChildren<MovementHandler>();
				if (!((Object)(object)componentInChildren == (Object)null))
				{
					componentInChildren.stopForTurns = !ShouldMoveWhileTurning(blueprint);
				}
			}
		}

		private static int GetBlueprintId(UnitBlueprint blueprint)
		{
			return ((Object)blueprint).GetInstanceID();
		}
	}
	internal static class MoveWhileTurningMetadata
	{
		private const string TagPattern = "\\u200B?\\[\\[TU:nostopturns=([01])\\]\\]";

		private static readonly Regex TagRegex = new Regex("\\u200B?\\[\\[TU:nostopturns=([01])\\]\\]", RegexOptions.Compiled);

		internal static string Strip(string description)
		{
			if (string.IsNullOrEmpty(description))
			{
				return string.Empty;
			}
			return TagRegex.Replace(description, string.Empty).TrimEnd(Array.Empty<char>());
		}

		internal static string EmbedForSave(string description, bool enabled, bool implicitNeverStop)
		{
			string text = Strip(description);
			if (enabled)
			{
				if (implicitNeverStop)
				{
					return text;
				}
				return text + "\u200b[[TU:nostopturns=1]]";
			}
			if (implicitNeverStop)
			{
				return text + "\u200b[[TU:nostopturns=0]]";
			}
			return text;
		}

		internal static bool TryParse(string description, out bool enabled, out string cleanDescription)
		{
			cleanDescription = Strip(description);
			enabled = false;
			if (string.IsNullOrEmpty(description))
			{
				return false;
			}
			Match match = TagRegex.Match(description);
			if (!match.Success)
			{
				return false;
			}
			enabled = match.Groups[1].Value == "1";
			return true;
		}
	}
	internal static class MoveWhileTurningRuntimePatches
	{
		public static void Spawn_Postfix(UnitBlueprint __instance, Unit unitToSpawn)
		{
			if (UnitEditorConfig.MoveWhileTurningEnabled && !((Object)(object)__instance == (Object)null) && !((Object)(object)unitToSpawn == (Object)null))
			{
				MoveWhileTurningHelper.ApplyToUnit(unitToSpawn, __instance);
			}
		}
	}
	[BepInPlugin("pretz.tabsunlimited", "TABS Unlimited", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <DeferredWarmFootstepIconCache>d__16 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DeferredWarmFootstepIconCache>d__16(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					FootstepIconResolver.WarmCache();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		internal static Plugin Instance { get; private set; }

		internal static void LogWarning(string message)
		{
			Plugin instance = Instance;
			if (instance != null)
			{
				((BaseUnityPlugin)instance).Logger.LogWarning((object)message);
			}
		}

		internal static void LogInfo(string message)
		{
			Plugin instance = Instance;
			if (instance != null)
			{
				((BaseUnityPlugin)instance).Logger.LogInfo((object)message);
			}
		}

		private void Awake()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			Instance = this;
			MirrorShieldConfig.Bind(((BaseUnityPlugin)this).Config);
			UnitEditorConfig.Bind(((BaseUnityPlugin)this).Config);
			TeamLineConfig.Bind(((BaseUnityPlugin)this).Config);
			WinConditionsConfig.Bind(((BaseUnityPlugin)this).Config);
			if (UnitEditorConfig.CustomVoicesEnabled)
			{
				CustomVoiceRegistry.Initialize();
			}
			if (UnitEditorConfig.CustomFootstepsEnabled)
			{
				((MonoBehaviour)this).StartCoroutine(DeferredWarmFootstepIconCache());
			}
			if (TeamLineConfig.Enabled)
			{
				TeamLineSquareBundlePreloader.PreloadFromPluginDirectory();
			}
			Harmony harmony = new Harmony("pretz.tabsunlimited");
			int num = 0;
			num += Patch(harmony, AccessTools.Method(typeof(GameStateManager), "EnterPlacementState", (Type[])null, (Type[])null), typeof(GameStatePatches), null, "EnterPlacementState_Postfix");
			num += Patch(harmony, AccessTools.Method(typeof(GameStateManager), "EnterBattleState", (Type[])null, (Type[])null), typeof(GameStatePatches), null, "EnterBattleState_Postfix");
			num += Patch(harmony, AccessTools.Method(typeof(GameStateManager), "EnterNoneState", (Type[])null, (Type[])null), typeof(GameStatePatches), null, "EnterNoneState_Postfix");
			num += Patch(harmony, AccessTools.Method(typeof(ProjectileHit), "Hit", new Type[2]
			{
				typeof(RaycastHit),
				typeof(float)
			}, (Type[])null), typeof(MirrorShieldPatches), "ProjectileHit_Hit_Prefix");
			num += Patch(harmony, AccessTools.Method(typeof(RaycastTrail), "Check", (Type[])null, (Type[])null), typeof(MirrorShieldPatches), "RaycastTrail_Check_Prefix");
			num += Patch(harmony, AccessTools.Method(typeof(SurfaceBlock), "DoEffect", (Type[])null, (Type[])null), typeof(MirrorShieldPatches), "SurfaceBlock_DoEffect_Prefix");
			num += Patch(harmony, AccessTools.Method(typeof(SurfaceReflect), "DoEffect", (Type[])null, (Type[])null), typeof(MirrorShieldPatches), "SurfaceReflect_DoEffect_Prefix");
			num += Patch(harmony, AccessTools.Method(typeof(BlockMove), "ProjectileBlock", (Type[])null, (Type[])null), typeof(MirrorShieldPatches), "BlockMove_ProjectileBlock_Prefix");
			num += Patch(harmony, AccessTools.Method(typeof(BlockMove), "SetDisabled", (Type[])null, (Type[])null), typeof(MirrorShieldPatches), "BlockMove_SetDisabled_Prefix");
			num += Patch(harmony, AccessTools.Method(typeof(BlockMoveHealth), "DoBlock", (Type[])null, (Type[])null), typeof(MirrorShieldPatches), "BlockMoveHealth_DoBlock_Prefix");
			num += Patch(harmony, AccessTools.Method(typeof(Charges), "UseCharge", (Type[])null, (Type[])null), typeof(MirrorShieldPatches), "Charges_UseCharge_Prefix");
			num += RegisterUnitEditorTargetingPatches(harmony);
			num += RegisterUnitEditorFootstepPatches(harmony);
			num += RegisterUnitEditorMoveWhileTurningPatches(harmony);
			num += RegisterUnitEditorFleeDistancePatches(harmony);
			num += RegisterUnitEditorCustomVoicePatches(harmony);
			num += RegisterCustomVoicePatches(harmony);
			num += RegisterTeamLinePatches(harmony);
			num += RegisterWinConditionPatches(harmony);
			((BaseUnityPlugin)this).Logger.LogInfo((object)string.Format("Loaded v{0} by {1} — Harmony {2} patches", "1.0.0", "Pretz", num));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Mirror shield: " + (MirrorShieldConfig.Improved ? "on" : "off")));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Unit editor targeting: " + (UnitEditorConfig.CustomTargetingTypesEnabled ? "on" : "off")));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Unit editor footsteps: " + (UnitEditorConfig.CustomFootstepsEnabled ? "on" : "off")));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Move while turning: " + (UnitEditorConfig.MoveWhileTurningEnabled ? "on" : "off")));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Flee distance editor: " + (UnitEditorConfig.FleeDistanceEnabled ? "on" : "off")));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Custom voices: " + (UnitEditorConfig.CustomVoicesEnabled ? "on" : "off")));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Team line: " + (TeamLineConfig.Enabled ? "on" : "off")));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Win conditions: " + (WinConditionsConfig.Enabled ? "on" : "off")));
		}

		private int RegisterUnitEditorTargetingPatches(Harmony harmony)
		{
			int num = 0;
			try
			{
				Type typeFromHandle = typeof(UnitEditorManager);
				Type typeFromHandle2 = typeof(UnitEditorUIManager);
				Type type = AccessTools.TypeByName("Landfall.TABS.AI.Components.Tags.ITargetingComponent, Assembly-CSharp");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "Awake", (Type[])null, (Type[])null), typeof(UnitEditorCustomTargeting), "Awake_Prefix");
				if (typeFromHandle2 != null)
				{
					num += Patch(harmony, AccessTools.Method(typeFromHandle2, "Start", (Type[])null, (Type[])null), typeof(UnitEditorCustomTargeting), "UIManager_Start_Prefix");
				}
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "LoadUnit", new Type[1] { typeof(UnitBlueprint) }, (Type[])null), typeof(UnitEditorCustomTargeting), "LoadUnit_Prefix");
				if (type != null)
				{
					MethodInfo methodInfo = AccessTools.Method(typeFromHandle, "GetTargetIndex", new Type[1] { type }, (Type[])null);
					if (methodInfo != null)
					{
						num += Patch(harmony, methodInfo, typeof(UnitEditorCustomTargeting), null, "GetTargetIndex_Postfix");
					}
				}
				Type type2 = AccessTools.TypeByName("EzECS.Barriers.PreUpdateBarrier, Assembly-CSharp");
				if (type2 != null)
				{
					MethodInfo methodInfo2 = AccessTools.Method(type2, "OnUpdate", (Type[])null, (Type[])null);
					if (methodInfo2 != null)
					{
						num += Patch(harmony, methodInfo2, typeof(CustomEnemyTargetingSystem), null, "PreUpdateBarrier_OnUpdate_Postfix");
					}
					else
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)"Custom targeting: PreUpdateBarrier.OnUpdate not found");
					}
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"Custom targeting: PreUpdateBarrier type not found");
				}
				MethodInfo methodInfo3 = AccessTools.Method(typeof(UnitECSToMonoSyncSystem), "OnUpdate", (Type[])null, (Type[])null);
				if (methodInfo3 != null)
				{
					num += Patch(harmony, methodInfo3, typeof(CustomEnemyTargetingSystem), null, "UnitECSToMonoSyncSystem_OnUpdate_Postfix");
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"Custom targeting: UnitECSToMonoSyncSystem.OnUpdate not found");
				}
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Unit editor targeting patches failed: {arg}");
			}
			return num;
		}

		private int RegisterUnitEditorFootstepPatches(Harmony harmony)
		{
			int num = 0;
			try
			{
				Type typeFromHandle = typeof(UnitEditorManager);
				Type typeFromHandle2 = typeof(UnitEditorUIManager);
				Type type = AccessTools.TypeByName("Landfall.TABS.UnitEditor.UnitEditorBasePageUI, Assembly-CSharp");
				Type typeFromHandle3 = typeof(UnitEditorListSelectScreen);
				Type type2 = AccessTools.TypeByName("UnitSounds, Assembly-CSharp");
				if (type != null)
				{
					num += Patch(harmony, AccessTools.Method(type, "Open", (Type[])null, (Type[])null), typeof(UnitEditorCustomFootsteps), null, "BasePage_Open_Postfix");
					num += Patch(harmony, AccessTools.Method(type, "Close", (Type[])null, (Type[])null), typeof(UnitEditorCustomFootsteps), null, "BasePage_Close_Postfix");
					num += Patch(harmony, AccessTools.Method(type, "PerformIncreaseAction", (Type[])null, (Type[])null), typeof(UnitEditorCustomFootsteps), "PerformIncreaseAction_Prefix");
					num += Patch(harmony, AccessTools.Method(type, "PerformDecreaseAction", (Type[])null, (Type[])null), typeof(UnitEditorCustomFootsteps), "PerformDecreaseAction_Prefix");
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"Unit footstep patches: UnitEditorBasePageUI type not found");
				}
				if (typeFromHandle2 != null)
				{
					num += Patch(harmony, AccessTools.Method(typeFromHandle2, "Start", (Type[])null, (Type[])null), typeof(UnitEditorCustomFootsteps), "UIManager_Start_Prefix");
					num += Patch(harmony, AccessTools.Method(typeFromHandle2, "GoToVoiceSelect", (Type[])null, (Type[])null), typeof(UnitEditorCustomFootsteps), "GoToVoiceSelect_Prefix");
				}
				num += Patch(harmony, AccessTools.Method(typeof(UnitEditorSelectableVoiceItem), "PreviewVoice", (Type[])null, (Type[])null), typeof(UnitEditorCustomFootsteps), "PreviewVoice_Prefix");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "EquipedVoiceBundle", (Type[])null, (Type[])null), typeof(UnitEditorCustomFootsteps), null, "EquipedVoiceBundle_Postfix");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "LoadUnit", new Type[1] { typeof(UnitBlueprint) }, (Type[])null), typeof(UnitEditorCustomFootsteps), null, "LoadUnit_Postfix");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "ClearUnit", (Type[])null, (Type[])null), typeof(UnitEditorCustomFootsteps), null, "ClearUnit_Postfix");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "GetBlueprint", (Type[])null, (Type[])null), typeof(UnitEditorCustomFootsteps), null, "GetBlueprint_Postfix");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "SwitchUnitBase", new Type[1] { typeof(int) }, (Type[])null), typeof(UnitEditorCustomFootsteps), null, "SwitchUnitBase_Postfix");
				MethodInfo methodInfo = AccessTools.Method(typeFromHandle, "RespawnUnit", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					num += Patch(harmony, methodInfo, typeof(UnitEditorCustomFootsteps), null, "RespawnUnit_Postfix");
				}
				num += Patch(harmony, AccessTools.Method(typeof(UnitBlueprint), "SerializedUnit", new Type[1] { typeof(DatabaseID) }, (Type[])null), typeof(UnitEditorCustomFootsteps), null, "SerializedUnit_Postfix");
				num += Patch(harmony, AccessTools.Method(typeof(UnitBlueprint), "DeserializedUnit", (Type[])null, (Type[])null), typeof(UnitEditorCustomFootsteps), null, "DeserializedUnit_Postfix");
				num += Patch(harmony, AccessTools.Method(typeof(UnitBlueprint), "Validate", (Type[])null, (Type[])null), typeof(FootstepRuntimePatches), null, "Validate_Postfix");
				MethodInfo methodInfo2 = AccessTools.GetDeclaredMethods(typeof(UnitBlueprint)).FirstOrDefault(delegate(MethodInfo m)
				{
					if (m.Name != "Spawn")
					{
						return false;
					}
					ParameterInfo[] parameters = m.GetParameters();
					return parameters.Length >= 4 && parameters[3].ParameterType.IsByRef && parameters[3].ParameterType.GetElementType() == typeof(Unit);
				});
				if (methodInfo2 != null)
				{
					num += Patch(harmony, methodInfo2, typeof(FootstepRuntimePatches), null, "Spawn_Postfix");
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"Unit footstep patches: UnitBlueprint.Spawn(out Unit) not found");
				}
				num += Patch(harmony, AccessTools.Method(typeFromHandle3, "OnClose", (Type[])null, (Type[])null), typeof(UnitEditorFootstepPicker), null, "ListSelect_OnClose_Postfix");
				num += Patch(harmony, AccessTools.Method(typeFromHandle3, "OnOpen", (Type[])null, (Type[])null), typeof(UnitEditorFootstepPicker), null, "ListSelect_OnOpen_Postfix");
				num += Patch(harmony, AccessTools.Method(typeof(UnitEditorVoiceSelectCell), "ValidInFilter", (Type[])null, (Type[])null), typeof(UnitEditorFootstepPicker), "VoiceSelectCell_ValidInFilter_Prefix");
				num += Patch(harmony, AccessTools.Method(typeof(UnitEditorVoiceSelectCell), "Play", (Type[])null, (Type[])null), typeof(UnitEditorFootstepPicker), "VoiceSelectCell_Play_Prefix");
				num += Patch(harmony, AccessTools.Method(typeof(UnitEditorVoiceSelectCell), "SelectVoice", (Type[])null, (Type[])null), typeof(UnitEditorFootstepPicker), "VoiceSelectCell_SelectVoice_Prefix");
				if (type2 != null)
				{
					MethodInfo methodInfo3 = AccessTools.Method(type2, "PlayFootSound", (Type[])null, (Type[])null);
					if (methodInfo3 != null)
					{
						num += Patch(harmony, methodInfo3, typeof(FootstepRuntimePatches), "PlayFootSound_Prefix");
					}
				}
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Unit editor footstep patches failed: {arg}");
			}
			return num;
		}

		private int RegisterUnitEditorMoveWhileTurningPatches(Harmony harmony)
		{
			int num = 0;
			if (!UnitEditorConfig.MoveWhileTurningEnabled)
			{
				return num;
			}
			try
			{
				Type typeFromHandle = typeof(UnitEditorManager);
				Type type = AccessTools.TypeByName("Landfall.TABS.UnitEditor.UnitEditorBasePageUI, Assembly-CSharp");
				if (type != null)
				{
					num += Patch(harmony, AccessTools.Method(type, "Open", (Type[])null, (Type[])null), typeof(UnitEditorMoveWhileTurning), null, "BasePage_Open_Postfix");
					num += Patch(harmony, AccessTools.Method(type, "Close", (Type[])null, (Type[])null), typeof(UnitEditorMoveWhileTurning), null, "BasePage_Close_Postfix");
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"Move while turning patches: UnitEditorBasePageUI type not found");
				}
				Type typeFromHandle2 = typeof(UnitEditorUIManager);
				if (typeFromHandle2 != null)
				{
					num += Patch(harmony, AccessTools.Method(typeFromHandle2, "Start", (Type[])null, (Type[])null), typeof(UnitEditorMoveWhileTurning), "UIManager_Start_Prefix");
				}
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "LoadUnit", new Type[1] { typeof(UnitBlueprint) }, (Type[])null), typeof(UnitEditorMoveWhileTurning), null, "LoadUnit_Postfix");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "ClearUnit", (Type[])null, (Type[])null), typeof(UnitEditorMoveWhileTurning), null, "ClearUnit_Postfix");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "GetBlueprint", (Type[])null, (Type[])null), typeof(UnitEditorMoveWhileTurning), null, "GetBlueprint_Postfix");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "SelectMovementType", new Type[1] { typeof(int) }, (Type[])null), typeof(UnitEditorMoveWhileTurning), null, "SelectMovementType_Postfix");
				MethodInfo methodInfo = AccessTools.Method(typeFromHandle, "RespawnUnit", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					num += Patch(harmony, methodInfo, typeof(UnitEditorMoveWhileTurning), null, "RespawnUnit_Postfix");
				}
				num += Patch(harmony, AccessTools.Method(typeof(UnitBlueprint), "SerializedUnit", new Type[1] { typeof(DatabaseID) }, (Type[])null), typeof(UnitEditorMoveWhileTurning), null, "SerializedUnit_Postfix");
				num += Patch(harmony, AccessTools.Method(typeof(UnitBlueprint), "DeserializedUnit", (Type[])null, (Type[])null), typeof(UnitEditorMoveWhileTurning), null, "DeserializedUnit_Postfix");
				MethodInfo methodInfo2 = AccessTools.GetDeclaredMethods(typeof(UnitBlueprint)).FirstOrDefault(delegate(MethodInfo m)
				{
					if (m.Name != "Spawn")
					{
						return false;
					}
					ParameterInfo[] parameters = m.GetParameters();
					return parameters.Length >= 4 && parameters[3].ParameterType.IsByRef && parameters[3].ParameterType.GetElementType() == typeof(Unit);
				});
				if (methodInfo2 != null)
				{
					num += Patch(harmony, methodInfo2, typeof(MoveWhileTurningRuntimePatches), null, "Spawn_Postfix");
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"Move while turning patches: UnitBlueprint.Spawn(out Unit) not found");
				}
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Move while turning patches failed: {arg}");
			}
			return num;
		}

		private int RegisterUnitEditorFleeDistancePatches(Harmony harmony)
		{
			int num = 0;
			if (!UnitEditorConfig.FleeDistanceEnabled)
			{
				return num;
			}
			try
			{
				Type typeFromHandle = typeof(UnitEditorManager);
				Type type = AccessTools.TypeByName("Landfall.TABS.UnitEditor.UnitEditorBasePageUI, Assembly-CSharp");
				Type type2 = AccessTools.TypeByName("Landfall.TABS.AI.Components.Modifiers.IMovementComponent, Assembly-CSharp");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "Awake", (Type[])null, (Type[])null), typeof(UnitEditorFleeDistance), "Awake_Prefix");
				Type typeFromHandle2 = typeof(UnitEditorUIManager);
				if (typeFromHandle2 != null)
				{
					num += Patch(harmony, AccessTools.Method(typeFromHandle2, "Start", (Type[])null, (Type[])null), typeof(UnitEditorFleeDistance), "UIManager_Start_Prefix");
				}
				if (type != null)
				{
					num += Patch(harmony, AccessTools.Method(type, "Open", (Type[])null, (Type[])null), typeof(UnitEditorFleeDistance), null, "BasePage_Open_Postfix");
					num += Patch(harmony, AccessTools.Method(type, "Close", (Type[])null, (Type[])null), typeof(UnitEditorFleeDistance), null, "BasePage_Close_Postfix");
					num += Patch(harmony, AccessTools.Method(type, "PerformIncreaseAction", (Type[])null, (Type[])null), typeof(UnitEditorFleeDistance), "PerformIncreaseAction_Prefix");
					num += Patch(harmony, AccessTools.Method(type, "PerformDecreaseAction", (Type[])null, (Type[])null), typeof(UnitEditorFleeDistance), "PerformDecreaseAction_Prefix");
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"Flee distance patches: UnitEditorBasePageUI type not found");
				}
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "LoadUnit", new Type[1] { typeof(UnitBlueprint) }, (Type[])null), typeof(UnitEditorFleeDistance), null, "LoadUnit_Postfix");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "ClearUnit", (Type[])null, (Type[])null), typeof(UnitEditorFleeDistance), null, "ClearUnit_Postfix");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "GetBlueprint", (Type[])null, (Type[])null), typeof(UnitEditorFleeDistance), "GetBlueprint_Prefix", "GetBlueprint_Postfix");
				num += Patch(harmony, AccessTools.Method(typeFromHandle, "SelectMovementType", new Type[1] { typeof(int) }, (Type[])null), typeof(UnitEditorFleeDistance), null, "SelectMovementType_Postfix");
				MethodInfo methodInfo = AccessTools.Method(typeFromHandle, "RespawnUnit", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					num += Patch(harmony, methodInfo, typeof(UnitEditorFleeDistance), null, "RespawnUnit_Postfix");
				}
				if (type2 != null)
				{
					MethodInfo methodInfo2 = AccessTools.Method(typeFromHandle, "GetMovementIndex", new Type[1] { type2 }, (Type[])null);
					if (methodInfo2 != null)
					{
						num += Patch(harmony, methodInfo2, typeof(UnitEditorFleeDistance), null, "GetMovementIndex_Postfix");
					}
				}
				num += Patch(harmony, AccessTools.Method(typeof(UnitBlueprint), "SerializedUnit", new Type[1] { typeof(DatabaseID) }, (Type[])null), typeof(UnitEditorFleeDistance), null, "SerializedUnit_Postfix");
				num += Patch(harmony, AccessTools.Method(typeof(UnitBlueprint), "DeserializedUnit", (Type[])null, (Type[])null), typeof(UnitEditorFleeDistance), null, "DeserializedUnit_Postfix");
				num += Patch(harmony, AccessTools.Method(typeof(UnitBlueprint), "DeserializedUnit", (Type[])null, (Type[])null), typeof(FleeDistanceRuntimeFix), null, "DeserializedUnit_Postfix");
				MethodInfo methodInfo3 = AccessTools.GetDeclaredMethods(typeof(UnitBlueprint)).FirstOrDefault(delegate(MethodInfo m)
				{
					if (m.Name != "Spawn")
					{
						return false;
					}
					ParameterInfo[] parameters = m.GetParameters();
					return parameters.Length >= 4 && parameters[3].ParameterType.IsByRef && parameters[3].ParameterType.GetElementType() == typeof(Unit);
				});
				if (methodInfo3 != null)
				{
					num += Patch(harmony, methodInfo3, typeof(FleeDistanceRuntimeFix), "Spawn_Prefix");
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)"Flee distance patches: UnitBlueprint.Spawn(out Unit) not found");
				}
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Flee distance patches failed: {arg}");
			}
			return num;
		}

		private int RegisterUnitEditorCustomVoicePatches(Harmony harmony)
		{
			int num = 0;
			if (!UnitEditorConfig.CustomVoicesEnabled)
			{
				return num;
			}
			try
			{
				Type type = AccessTools.TypeByName("Landfall.TABS.UnitEditor.UnitEditorBasePageUI, Assembly-CSharp");
				if (type != null)
				{
					num += Patch(harmony, AccessTools.Method(type, "Open", (Type[])null, (Type[])null), typeof(UnitEditorCustomVoiceButton), null, "BasePage_Open_Postfix");
				}
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Unit editor custom voice patches failed: {arg}");
			}
			return num;
		}

		private int RegisterCustomVoicePatches(Harmony harmony)
		{
			int applied = 0;
			try
			{
				CustomVoiceDatabasePatches.Register(harmony, ref applied);
				CustomVoiceDeserializePatches.Register(harmony, ref applied);
				CustomVoiceValidatePatches.Register(harmony, ref applied);
				CustomVoiceVoiceSelectPatches.Register(harmony, ref applied);
				CustomVoiceUnitPagePreviewPatches.Register(harmony, ref applied);
				CustomVoiceUnitSoundsPatches.Register(harmony, ref applied);
				CustomVoiceUnitButtonPatches.Register(harmony, ref applied);
				CustomVoiceSpawnPatches.Register(harmony, ref applied);
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Custom voice patches failed: {arg}");
			}
			return applied;
		}

		private int RegisterWinConditionPatches(Harmony harmony)
		{
			if (!WinConditionsConfig.Enabled)
			{
				return 0;
			}
			try
			{
				int applied = 0;
				WinConditionUiPatches.Register(harmony, ref applied);
				return applied;
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Win condition patches failed: {arg}");
				return 0;
			}
		}

		private int RegisterTeamLinePatches(Harmony harmony)
		{
			if (!TeamLineConfig.Enabled)
			{
				return 0;
			}
			int applied = 0;
			TeamLineSquareAssets.TryLoad();
			try
			{
				applied += Patch(harmony, AccessTools.Method(typeof(SceneSettings), "GetTeamTerritoryInternal", (Type[])null, (Type[])null), typeof(TeamLineSquarePatches), "GetTeamTerritoryInternal_Prefix");
				applied += Patch(harmony, AccessTools.Method(typeof(SceneSettings), "Update", (Type[])null, (Type[])null), typeof(TeamLineSquarePatches), "Update_Prefix");
				applied += Patch(harmony, AccessTools.Method(typeof(SceneSettings), "StartLineEditing", (Type[])null, (Type[])null), typeof(TeamLineSquarePatches), null, "StartLineEditing_Postfix");
				applied += Patch(harmony, AccessTools.Method(typeof(SceneSettings), "ResetToDefaultTeamLine", (Type[])null, (Type[])null), typeof(TeamLineSquarePatches), "ResetToDefaultTeamLine_Prefix", "ResetToDefaultTeamLine_Postfix");
				applied += Patch(harmony, AccessTools.Method(typeof(MapSettingsUI), "EditTeamLine", (Type[])null, (Type[])null), typeof(TeamLineSquarePatches), null, "MapSettingsUiEditTeamLine_Postfix");
				MethodInfo methodInfo = AccessTools.Method(typeof(MapSettingsComponent), "StartEditingTeamLine", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					applied += Patch(harmony, methodInfo, typeof(TeamLineSquarePatches), null, "MapSettingsComponentStartEditingTeamLine_Postfix");
				}
				applied += Patch(harmony, AccessTools.Method(typeof(SceneSettings), "ShowCircleSettings", (Type[])null, (Type[])null), typeof(TeamLineSquarePatches), null, "ShowCircleSettings_Postfix");
				MethodInfo methodInfo2 = AccessTools.Method(typeof(MapSettingsComponent), "CycleLineType", (Type[])null, (Type[])null);
				if (methodInfo2 != null)
				{
					applied += Patch(harmony, methodInfo2, typeof(TeamLineSquarePatches), "CycleLineType_Prefix");
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogError((object)"Team line: MapSettingsComponent.CycleLineType not found");
				}
				applied += Patch(harmony, AccessTools.Method(typeof(MapSettingsComponent), "GetHelpText", (Type[])null, (Type[])null), typeof(TeamLineSquarePatches), "MapSettingsGetHelpText_Prefix");
				applied += Patch(harmony, AccessTools.Method(typeof(MapSettingsUI), "GetHelpText", (Type[])null, (Type[])null), typeof(TeamLineSquarePatches), "MapSettingsUiGetHelpText_Prefix");
				applied += Patch(harmony, AccessTools.Method(typeof(MapSettingsUI), "Start", (Type[])null, (Type[])null), typeof(TeamLineSquarePatches), null, "MapSettingsUiStart_Postfix");
				applied += Patch(harmony, AccessTools.Method(typeof(MapSettingsUI), "UpdateUI", (Type[])null, (Type[])null), typeof(TeamLineSquarePatches), null, "MapSettingsUiUpdateUi_Postfix");
				applied += Patch(harmony, AccessTools.Method(typeof(GlobalTeamEdgeSettings), "GetSettings", (Type[])null, (Type[])null), typeof(TeamLineSquarePatches), "GlobalTeamEdgeGetSettings_Prefix");
				try
				{
					TeamLineSquareBorderRender.TryRegister(harmony, ref applied);
				}
				catch (Exception arg)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)$"Square team line render patch failed: {arg}");
				}
				try
				{
					TeamLineSquareCameraPatches.TryRegister(harmony, ref applied);
				}
				catch (Exception arg2)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)$"Square camera patches failed: {arg2}");
				}
				try
				{
					TeamLineSquarePlacementPatches.TryRegister(harmony, ref applied);
				}
				catch (Exception arg3)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)$"Square placement restore patch failed: {arg3}");
				}
			}
			catch (Exception arg4)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Team line patches failed: {arg4}");
			}
			return applied;
		}

		private int Patch(Harmony harmony, MethodBase original, Type patchClass, string prefix = null, string postfix = null, string transpiler = null)
		{
			//IL_0047: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			if (original == null)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Patch target missing: " + patchClass.Name + "." + (prefix ?? postfix ?? transpiler)));
				return 0;
			}
			try
			{
				object obj = harmony;
				obj = original;
				obj = (object)((prefix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(patchClass, prefix, (Type[])null));
				obj = (object)((postfix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(patchClass, postfix, (Type[])null));
				obj = (object)((transpiler == null) ? ((HarmonyMethod)null) : new HarmonyMethod(patchClass, transpiler, (Type[])null));
				((Harmony)obj).Patch((MethodBase)obj, (HarmonyMethod)obj, (HarmonyMethod)obj, (HarmonyMethod)obj, (HarmonyMethod)null, (HarmonyMethod)null);
				return 1;
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Failed to patch " + original.DeclaringType?.Name + "." + original.Name + ": " + ex.Message));
				return 0;
			}
		}

		[IteratorStateMachine(typeof(<DeferredWarmFootstepIconCache>d__16))]
		private static IEnumerator DeferredWarmFootstepIconCache()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DeferredWarmFootstepIconCache>d__16(0);
		}
	}
	internal static class TeamLineConfig
	{
		internal static bool Enabled = true;

		internal static void Bind(ConfigFile config)
		{
			Enabled = config.Bind<bool>("TeamLine", "Enabled", true, "Enable square team line type in the map editor (Line, Circle, Square).").Value;
		}
	}
	internal static class UnitBlueprintCombatHelper
	{
		private static readonly Dictionary<UnitBlueprint, bool?> RangedClassificationCache = new Dictionary<UnitBlueprint, bool?>();

		internal static void InvalidateRangedCache()
		{
			RangedClassificationCache.Clear();
		}

		internal static bool? ClassifyIsRanged(UnitBlueprint blueprint)
		{
			if ((Object)(object)blueprint == (Object)null)
			{
				return null;
			}
			if (RangedClassificationCache.TryGetValue(blueprint, out var value))
			{
				return value;
			}
			bool flag = HasWeaponComponent<MeleeWeapon>(blueprint.RightWeapon) || HasWeaponComponent<MeleeWeapon>(blueprint.LeftWeapon);
			bool flag2 = HasWeaponComponent<RangeWeapon>(blueprint.RightWeapon) || HasWeaponComponent<RangeWeapon>(blueprint.LeftWeapon);
			bool? flag3 = ((flag2 && flag) ? null : (flag2 ? new bool?(true) : ((!flag) ? null : new bool?(false))));
			RangedClassificationCache[blueprint] = flag3;
			return flag3;
		}

		private static bool HasWeaponComponent<T>(GameObject weaponObject) where T : Component
		{
			if ((Object)(object)weaponObject == (Object)null)
			{
				return false;
			}
			return (Object)(object)weaponObject.GetComponentInChildren<T>(true) != (Object)null;
		}
	}
	internal static class UnitEditorBasePageScroll
	{
		[CompilerGenerated]
		private sealed class <SetupScrollAfterOpen>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public UnitEditorBasePageUI basePage;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SetupScrollAfterOpen>d__6(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_006c: 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_00bc: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					_setupCoroutine = null;
					if ((Object)(object)basePage == (Object)null)
					{
						return false;
					}
					Stopwatch stopwatch = null;
					RectTransform val = ResolveContent(basePage);
					if ((Object)(object)val == (Object)null)
					{
						return false;
					}
					if (UnitEditorContentScroll.TryFastReopen(val, ScrollConfig))
					{
						LogLayoutDebug(val, val.anchoredPosition, fastPath: true);
						if (stopwatch != null)
						{
							stopwatch.Stop();
							UnitEditorFootstepDebug.Log($"BaseScroll open: fastPath {stopwatch.ElapsedMilliseconds}ms");
						}
						return false;
					}
					Transform transform = ((Component)basePage).transform;
					RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
					if (val2 != null)
					{
						UnitEditorContentScroll.ForceLayoutChain(val2);
					}
					Vector2 anchoredPosition = val.anchoredPosition;
					UnitEditorContentScroll.PrepareSharedViewport(val);
					UnitEditorContentScroll.ForceLayoutChain(val);
					EnsureSetup(basePage, val);
					LogLayoutDebug(val, anchoredPosition, fastPath: false);
					if (stopwatch != null)
					{
						stopwatch.Stop();
						UnitEditorFootstepDebug.Log($"BaseScroll open: fullSetup {stopwatch.ElapsedMilliseconds}ms");
					}
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private const string FootstepHeaderName = "StayCombatFix_FootstepHeader";

		private static Coroutine _setupCoroutine;

		private static readonly FieldInfo ContentParentField = AccessTools.Field(typeof(UnitEditorBasePageUI), "contentParent");

		private static readonly UnitEditorContentScroll.Config ScrollConfig = new UnitEditorContentScroll.Config
		{
			InnerContainerName = "BaseScrollInner",
			ClipViewportName = "BaseClipViewport",
			NavCoverName = "BaseNavCover",
			IsScrollRow = IsBasePageScrollRow,
			Mode = UnitEditorContentScroll.ScrollMode.DirectContentY
		};

		internal static void ScheduleSetup(UnitEditorBasePageUI basePage)
		{
			if (UnitEditorConfig.CustomFootstepsEnabled && !((Object)(object)basePage == (Object)null) && !((Object)(object)Plugin.Instance == (Object)null))
			{
				if (_setupCoroutine != null)
				{
					((MonoBehaviour)Plugin.Instance).StopCoroutine(_setupCoroutine);
					_setupCoroutine = null;
				}
				_setupCoroutine = ((MonoBehaviour)Plugin.Instance).StartCoroutine(SetupScrollAfterOpen(basePage));
			}
		}

		internal static void Cleanup(UnitEditorBasePageUI basePage, bool fullRollback = false)
		{
			if ((Object)(object)basePage == (Object)null)
			{
				return;
			}
			RectTransform val = ResolveContent(basePage);
			if (!((Object)(object)val == (Object)null))
			{
				Stopwatch stopwatch = null;
				if (fullRollback)
				{
					UnitEditorContentScroll.RollbackToVanillaLayout(val, ScrollConfig);
				}
				else
				{
					UnitEditorContentScroll.ResetScrollState(val, ScrollConfig);
				}
				if (stopwatch != null)
				{
					stopwatch.Stop();
					UnitEditorFootstepDebug.Log(string.Format("BaseScroll close: {0} {1}ms", fullRollback ? "fullRollback" : "reset", stopwatch.ElapsedMilliseconds));
				}
			}
		}

		[IteratorStateMachine(typeof(<SetupScrollAfterOpen>d__6))]
		private static IEnumerator SetupScrollAfterOpen(UnitEditorBasePageUI basePage)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SetupScrollAfterOpen>d__6(0)
			{
				basePage = basePage
			};
		}

		private static void EnsureSetup(UnitEditorBasePageUI basePage, RectTransform content)
		{
			if (UnitEditorConfig.CustomFootstepsEnabled && !((Object)(object)content == (Object)null) && ((Transform)content).childCount > 0)
			{
				UnitEditorContentScroll.EnsureSetup(content, ((Component)basePage).transform, ScrollConfig, "BaseScroll");
			}
		}

		private static void LogLayoutDebug(RectTransform content, Vector2 beforePosition, bool fastPath)
		{
			//IL_006d: 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)
			if ((Object)(object)content == (Object)null)
			{
				return;
			}
			bool flag = (Object)(object)((Transform)content).Find(ScrollConfig.InnerContainerName) != (Object)null;
			float num = float.NaN;
			for (int i = 0; i < ((Transform)content).childCount; i++)
			{
				Transform child = ((Transform)content).GetChild(i);
				RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
				if (val != null && IsBasePageScrollRow((Transform)(object)val))
				{
					num = GetWorldLeft(val);
					break;
				}
			}
			UnitEditorFootstepDebug.Log(string.Format("BaseScroll: path={0} before={1} after={2} ", fastPath ? "fast" : "full", beforePosition, content.anchoredPosition) + $"contentLeft={GetWorldLeft(content):0.##} firstRowLeft={num:0.##} " + $"hasInner={flag}");
		}

		private static float GetWorldLeft(RectTransform rect)
		{
			if ((Object)(object)rect == (Object)null)
			{
				return float.NaN;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			rect.GetWorldCorners(array);
			return array[0].x;
		}

		private static RectTransform ResolveContent(UnitEditorBasePageUI basePage)
		{
			object? obj = ContentParentField?.GetValue(basePage);
			Transform val = (Transform)((obj is Transform) ? obj : null);
			if (val == null)
			{
				return null;
			}
			return UnitEditorContentScroll.ResolveContentRect(val);
		}

		internal static bool IsBasePageScrollRow(Transform child)
		{
			if ((Object)(object)child == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)child).GetComponent<UnitEditorSelectableItem>() != (Object)null)
			{
				return true;
			}
			return string.Equals(((Object)child).name, "StayCombatFix_FootstepHeader", StringComparison.Ordinal);
		}
	}
	internal static class UnitEditorConfig
	{
		internal static bool CustomTargetingTypesEnabled = true;

		internal static bool CustomFootstepsEnabled = true;

		internal static bool MoveWhileTurningEnabled = true;

		internal static bool CustomVoicesEnabled = true;

		internal static bool FleeDistanceEnabled = true;

		internal const bool CustomFootstepsDebug = false;

		internal const float FootstepPitchMin = 0.5f;

		internal const float FootstepPitchMax = 1.5f;

		internal const float ShortRangeAttackThreshold = 15f;

		internal const float ShortRangeNearFraction = 0.75f;

		internal const float ShortRangeApproachMultiplier = 2.5f;

		internal const float LongRangeNearFraction = 0.5f;

		internal const float LongRangeApproachMultiplier = 1.5f;

		internal const float RangedEnemiesShortNearFraction = 0.5f;

		internal const float RangedEnemiesLongNearFraction = 0.25f;

		internal const float CustomEnemyTargetingRetargetInterval = 0.25f;

		internal const float CustomVoicePreviewVolume = 0.18f;

		internal const float CustomVoiceBattleVolume = 0.5f;

		internal const float CustomVoiceMaxDurationSeconds = 7f;

		private static readonly ConfigDefinition[] OrphanedKeys = (ConfigDefinition[])(object)new ConfigDefinition[44]
		{
			new ConfigDefinition("UnitEditor", "NearRangeAttackRangeFraction"),
			new ConfigDefinition("UnitEditor", "MaxSearchRangeMultiplier"),
			new ConfigDefinition("UnitEditor", "ShortRangeAttackThreshold"),
			new ConfigDefinition("UnitEditor", "ShortRangeNearFraction"),
			new ConfigDefinition("UnitEditor", "ShortRangeApproachMultiplier"),
			new ConfigDefinition("UnitEditor", "LongRangeNearFraction"),
			new ConfigDefinition("UnitEditor", "LongRangeApproachMultiplier"),
			new ConfigDefinition("UnitEditor", "RangedEnemiesShortNearFraction"),
			new ConfigDefinition("UnitEditor", "RangedEnemiesLongNearFraction"),
			new ConfigDefinition("UnitEditor", "MostExpensiveEnemyRetargetInterval"),
			new ConfigDefinition("UnitEditor", "CustomEnemyTargetingRetargetInterval"),
			new ConfigDefinition("UnitEditor", "CustomFootstepsDebug"),
			new ConfigDefinition("UnitEditor", "FootstepPitchMin"),
			new ConfigDefinition("UnitEditor", "FootstepPitchMax"),
			new ConfigDefinition("CustomVoices", "PreviewVolume"),
			new ConfigDefinition("CustomVoices", "BattleVolume"),
			new ConfigDefinition("CustomVoices", "MaxDurationSeconds"),
			new ConfigDefinition("UnitEditor", "FleeDistanceDebugDrawPaths"),
			new ConfigDefinition("UnitEditor", "FleeDistanceDebugDrawThreat"),
			new ConfigDefinition("UnitEditor", "FleeDistanceDebugDrawClearance"),
			new ConfigDefinition("UnitEditor", "FleeDistanceDebugLogEvents"),
			new ConfigDefinition("UnitEditor", "FleeDistanceSmartRoutingEnabled"),
			new ConfigDefinition("UnitEditor", "FleeDistanceClearanceRoutingEnabled"),
			new ConfigDefinition("UnitEditor", "FleeDistanceRangedUntilFleeEnabled"),
			new ConfigDefinition("UnitEditor", "FleeDistancePathfindingEnabled"),
			new ConfigDefinition("UnitEditor", "FleeDistanceDebugEnabled"),
			new ConfigDefinition("UnitEditor", "FleeDistanceMinEdgeClearance"),
			new ConfigDefinition("UnitEditor", "FleeDistanceMaxStepHeight"),
			new ConfigDefinition("UnitEditor", "FleeDistanceStallRecoveryCooldown"),
			new ConfigDefinition("UnitEditor", "FleeDistancePathMinLength"),
			new ConfigDefinition("UnitEditor", "FleeDistancePathMaxLength"),
			new ConfigDefinition("UnitEditor", "FleeDistanceSwapDistance"),
			new ConfigDefinition("UnitEditor", "FleeDistanceSearchConeDegrees"),
			new ConfigDefinition("UnitEditor", "FleeDistanceFleeExitHysteresis"),
			new ConfigDefinition("UnitEditor", "FleeDistanceCornerEscapeEnemyDistance"),
			new ConfigDefinition("UnitEditor", "FleeDistanceCornerEscapeStallSeconds"),
			new ConfigDefinition("UnitEditor", "FleeDistanceCornerEscapeMinProgress"),
			new ConfigDefinition("UnitEditor", "FleeDistancePostFleeAttackCooldown"),
			new ConfigDefinition("UnitEditor", "FleeDistanceThreatSnapshotInterval"),
			new ConfigDefinition("UnitEditor", "FleeDistanceMaxPathSearchesPerFrame"),
			new ConfigDefinition("UnitEditor", "FleeDistanceMaxNewPathSearchSessionsPerFrame"),
			new ConfigDefinition("UnitEditor", "FleeDistanceIdleThreatCheckIntervalFrames"),
			new ConfigDefinition("UnitEditor", "FleeDistanceHighLoadFleeUnitThreshold"),
			new ConfigDefinition("UnitEditor", "FleeDistanceSkipBackgroundPathSearchUnderLoad")
		};

		internal static void Bind(ConfigFile config)
		{
			ConfigDefinition[] orphanedKeys = OrphanedKeys;
			foreach (ConfigDefinition val in orphanedKeys)
			{
				config.Remove(val);
			}
			CustomTargetingTypesEnabled = config.Bind<bool>("UnitEditor", "CustomTargetingTypes", true, "Enable custom unit editor targeting types (Most Expensive Enemy, Lowest Health Enemy, Ranged Enemies).").Value;
			CustomFootstepsEnabled = config.Bind<bool>("UnitEditor", "CustomFootsteps", true, "Enable UNIT FOOTSTEP row in the unit editor (type picker, preview, pitch slider).").Value;
			MoveWhileTurningEnabled = config.Bind<bool>("UnitEditor", "MoveWhileTurningEnabled", true, "Enable Move While Turning toggle on the BASE tab.").Value;
			FleeDistanceEnabled = config.Bind<bool>("UnitEditor", "FleeDistanceEnabled", true, "Enable FLEE DISTANCE movement type with editable flee distance (WM) on the BASE tab. Runtime flee AI requires Stay & Combat Fixes.").Value;
			CustomVoicesEnabled = config.Bind<bool>("CustomVoices", "Enabled", true, "Enable custom voice packs in the unit editor (Custom Voices button on the BASE tab Unit Voice row).").Value;
		}
	}
	internal static class UnitEditorContentScroll
	{
		internal enum ScrollMode
		{
			InnerContainer,
			DirectContentY
		}

		internal sealed class Config
		{
			internal string InnerContainerName;

			internal string ClipViewportName;

			internal string NavCoverName;

			internal Func<Transform, bool> IsScrollRow;

			internal Action<RectTransform, RectTransform> ConfigureInnerLayout;

			internal bool PreserveWorldPositionOnReparent;

			internal ScrollMode Mode;
		}

		internal sealed class UnitEditorContentScroller : MonoBehaviour
		{
			private Config _config;

			private RectTransform _viewport;

			private RectTransform _scrollContent;

			private Transform _pageRoot;

			private float _scrollOffset;

			private float _maxScroll;

			private Vector2 _vanillaAnchoredPosition;

			private bool _useDirectContentY;

			internal bool Configure(RectTransform viewport, Transform pageRoot, Config config)
			{
				_viewport = viewport;
				_pageRoot = pageRoot;
				_config = config;
				_useDirectContentY = config != null && config.Mode == ScrollMode.DirectContentY;
				if (_useDirectContentY)
				{
					CaptureVanillaAnchoredPosition(viewport);
					_scrollContent = viewport;
				}
				else
				{
					_scrollContent = EnsureInnerContainer(viewport, config);
				}
				_scrollOffset = 0f;
				ApplyScrollOffset();
				if (ShouldRollback(_scrollContent, config))
				{
					return false;
				}
				ForceLayoutChain(_viewport);
				if (!_useDirectContentY)
				{
					ForceLayoutChain(_scrollContent);
				}
				RefreshMetrics();
				return true;
			}

			private void CaptureVanillaAnchoredPosition(RectTransform viewport)
			{
				//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_0037: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)viewport == (Object)null))
				{
					int instanceID = ((Object)viewport).GetInstanceID();
					if (!VanillaAnchoredPositions.TryGetValue(instanceID, out _vanillaAnchoredPosition))
					{
						_vanillaAnchoredPosition = viewport.anchoredPosition;
						VanillaAnchoredPositions[instanceID] = _vanillaAnchoredPosition;
					}
				}
			}

			internal bool IsConfiguredFor(Config config)
			{
				if (_config == null || config == null)
				{
					return false;
				}
				if (_config.Mode == config.Mode && string.Equals(_config.InnerContainerName, config.InnerContainerName, StringComparison.Ordinal))
				{
					return (object)_config.IsScrollRow == config.IsScrollRow;
				}
				return false;
			}

			internal void ResetScrollOffset()
			{
				_scrollOffset = 0f;
				ApplyScrollOffset();
			}

			internal void RefreshScrollMetrics()
			{
				RefreshMetrics();
			}

			private void OnEnable()
			{
				if ((Object)(object)_scrollContent != (Object)null)
				{
					_scrollOffset = 0f;
					ApplyScrollOffset();
				}
			}

			private void Update()
			{
				//IL_0016: 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_004d: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)_scrollContent == (Object)null) && _config != null && Input.mouseScrollDelta.y != 0f && IsPointerOverScrollArea(_viewport, _scrollContent, _config, Vector2.op_Implicit(Input.mousePosition)))
				{
					ScrollBy((0f - Input.mouseScrollDelta.y) * 90f);
				}
			}

			private void RefreshMetrics()
			{
				if (!((Object)(object)_viewport == (Object)null) && !((Object)(object)_scrollContent == (Object)null) && _config != null)
				{
					ForceLayoutChain(_viewport);
					if (!_useDirectContentY)
					{
						ForceLayoutChain(_scrollContent);
					}
					if (TryMeasureRowBounds(_scrollContent, _config, out var highestTop, out var lowestBottom))
					{
						float contentExtent = Mathf.Max(0f, highestTop - lowestBottom);
						float viewportHeight = ResolveScrollViewportHeight(_viewport, _pageRoot);
						float bottomClearance = ComputeBottomObstructionInset(_viewport, _pageRoot);
						_maxScroll = ComputeMaxScroll(viewportHeight, contentExtent, bottomClearance);
						_scrollOffset = Mathf.Clamp(_scrollOffset, 0f, _maxScroll);
						ApplyScrollOffset();
					}
				}
			}

			private void ApplyScrollOffset()
			{
				//IL_0050: 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_0075: 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_0043: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)_scrollContent == (Object)null))
				{
					if (_useDirectContentY && (Object)(object)_viewport != (Object)null)
					{
						Vector2 vanillaAnchoredPosition = _vanillaAnchoredPosition;
						vanillaAnchoredPosition.y += _scrollOffset;
						_viewport.anchoredPosition = vanillaAnchoredPosition;
					}
					else
					{
						Vector2 anchoredPosition = _scrollContent.anchoredPosition;
						anchoredPosition.x = 0f;
						anchoredPosition.y = _scrollOffset;
						_scrollContent.anchoredPosition = anchoredPosition;
					}
				}
			}

			private void ScrollBy(float delta)
			{
				RefreshMetrics();
				if (!(_maxScroll <= 0.5f))
				{
					_scrollOffset = Mathf.Clamp(_scrollOffset + delta, 0f, _maxScroll);
					ApplyScrollOffset();
				}
			}

			private static RectTransform EnsureInnerContainer(RectTransform content, Config config)
			{
				//IL_0037: 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_006a: 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_008a: 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_00cd: 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)
				Transform obj = ((Transform)content).Find(config.InnerContainerName);
				RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					val = new GameObject(config.InnerContainerName, new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
					((Transform)val).SetParent((Transform)(object)content, false);
					val.anchorMin = new Vector2(0f, 1f);
					val.anchorMax = new Vector2(1f, 1f);
					val.pivot = new Vector2(0f, 1f);
					val.anchoredPosition = Vector2.zero;
					val.sizeDelta = Vector2.zero;
				}
				AlignInnerContainerTopLeft(val);
				ReparentScrollChildren(content, val, config);
				config.ConfigureInnerLayout?.Invoke(content, val);
				AlignInnerContainerTopLeft(val);
				val.anchoredPosition = new Vector2(0f, val.anchoredPosition.y);
				return val;
			}

			private static void ReparentScrollChildren(RectTransform from, RectTransform inner, Config config)
			{
				ReparentPreservingOrder((Transform)(object)from, (Transform)(object)inner, (Transform child) => (Object)(object)child != (Object)(object)inner && (Object)(object)((Component)child).GetComponent<UnitEditorContentScroller>() == (Object)null && ((Object)child).name != config.ClipViewportName && ((Object)child).name != config.NavCoverName && ((Object)child).name != config.InnerContainerName, config.PreserveWorldPositionOnReparent);
			}

			private static bool ShouldRollback(RectTransform scrollContent, Config config)
			{
				if ((Object)(object)scrollContent == (Object)null || config == null || config.IsScrollRow == null)
				{
					return true;
				}
				if (((Transform)scrollContent).childCount <= 0)
				{
					return true;
				}
				return CountRows(scrollContent, config) <= 0;
			}

			private static int CountRows(RectTransform scrollContent, Config config)
			{
				int num = 0;
				for (int i = 0; i < ((Transform)scrollContent).childCount; i++)
				{
					if (config.IsScrollRow(((Transform)scrollContent).GetChild(i)))
					{
						num++;
					}
				}
				return num;
			}

			private static bool TryMeasureRowBounds(RectTransform scrollContent, Config config, out float highestTop, out float lowestBottom)
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				highestTop = float.NegativeInfinity;
				lowestBottom = float.PositiveInfinity;
				int num = 0;
				if ((Object)(object)scrollContent == (Object)null || config == null || config.IsScrollRow == null)
				{
					return false;
				}
				LayoutRebuilder.ForceRebuildLayoutImmediate(scrollContent);
				for (int i = 0; i < ((Transform)scrollContent).childCount; i++)
				{
					Transform child = ((Transform)scrollContent).GetChild(i);
					RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
					if (val != null && ((Component)val).gameObject.activeInHierarchy && config.IsScrollRow((Transform)(object)val))
					{
						num++;
						Vector3[] array = (Vector3[])(object)new Vector3[4];
						val.GetWorldCorners(array);
						float y = ((Transform)scrollContent).InverseTransformPoint(array[1]).y;
						float y2 = ((Transform)scrollContent).InverseTransformPoint(array[0]).y;
						if (y > highestTop)
						{
							highestTop = y;
						}
						if (y2 < lowestBottom)
						{
							lowestBottom = y2;
						}
					}
				}
				return num > 0;
			}

			private static bool IsPointerOverScrollArea(RectTransform viewport, RectTransform scrollContent, Config config, Vector2 screenPosition)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				if (ContainsScreenPoint(viewport, screenPosition))
				{
					return true;
				}
				if ((Object)(object)scrollContent == (Object)null || config == null || config.IsScrollRow == null)
				{
					return false;
				}
				for (int i = 0; i < ((Transform)scrollContent).childCount; i++)
				{
					Transform child = ((Transform)scrollContent).GetChild(i);
					RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
					if (val != null && ((Component)val).gameObject.activeInHierarchy && config.IsScrollRow((Transform)(object)val) && ContainsScreenPoint(val, screenPosition))
					{
						return true;
					}
				}
				return false;
			}

			private static bool ContainsScreenPoint(RectTransform rect, Vector2 screenPosition)
			{
				//IL_000c: 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)
				if ((Object)(object)rect == (Object)null)
				{
					return false;
				}
				if (RectTransformUtility.RectangleContainsScreenPoint(rect, screenPosition, (Camera)null))
				{
					return true;
				}
				Canvas componentInParent = ((Component)rect).GetComponentInParent<Canvas>();
				Camera val = (((Object)(object)componentInParent != (Object)null) ? componentInParent.worldCamera : null);
				if ((Object)(object)val != (Object)null && RectTransformUtility.RectangleContainsScreenPoint(rect, screenPosition, val))
				{
					return true;
				}
				return false;
			}

			private static float GetRectTopY(RectTransform rect)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				rect.GetWorldCorners(array);
				return array[1].y;
			}

			private static float GetRectBottomY(RectTransform rect)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				rect.GetWorldCorners(array);
				return array[0].y;
			}

			private static float GetWorldRectHeight(RectTransform rect)
			{
				if ((Object)(object)rect == (Object)null)
				{
					return 0f;
				}
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				rect.GetWorldCorners(array);
				return Mathf.Abs(array[1].y - array[0].y);
			}

			private static float ResolveRectHeight(RectTransform rect)
			{
				//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)
				if ((Object)(object)rect == (Object)null)
				{
					return 0f;
				}
				float worldRectHeight = GetWorldRectHeight(rect);
				if (worldRectHeight >= 1f)
				{
					return worldRectHeight;
				}
				Rect rect2 = rect.rect;
				return ((Rect)(ref rect2)).height;
			}

			private static float ResolveScreenVisibleHeight()
			{
				return Mathf.Max(100f, (float)Screen.height - 90f - 100f);
			}

			private static float ResolveScrollViewportHeight(RectTransform viewport, Transform pageRoot)
			{
				if ((Object)(object)viewport == (Object)null)
				{
					return ResolveScreenVisibleHeight();
				}
				ForceLayoutChain(viewport);
				float num = ResolveRectHeight(viewport);
				if (num >= 100f)
				{
					return num;
				}
				Transform parent = ((Transform)viewport).parent;
				RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)pageRoot)
				{
					num = ResolveRectHeight(val);
					if (num >= 100f)
					{
						return num;
					}
					Transform parent2 = ((Transform)val).parent;
					val = (RectTransform)(object)((parent2 is RectTransform) ? parent2 : null);
				}
				return ResolveScreenVisibleHeight();
			}

			private static float ComputeBottomObstructionInset(RectTransform viewport, Transform pageRoot)
			{
				RectTransform val = (RectTransform)(object)((pageRoot is RectTransform) ? pageRoot : null);
				if (val == null)
				{
					return 100f;
				}
				float rectBottomY = GetRectBottomY(val);
				float bestClearance = 100f;
				ConsiderBottomUi(val, viewport, rectBottomY, ref bestClearance);
				Transform parent = ((Transform)val).parent;
				RectTransform val2 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				if (val2 != null)
				{
					ConsiderBottomUi(val2, viewport, rectBottomY, ref bestClearance);
				}
				return bestClearance + 50f;
			}

			private static void ConsiderBottomUi(RectTransform root, RectTransform viewport, float pageBottom, ref float bestClearance)
			{
				for (int i = 0; i < ((Transform)root).childCount; i++)
				{
					Transform child = ((Transform)root).GetChild(i);
					RectTransform val = (RectTransform)(object)((child is RectTransform) ? child : null);
					if (val == null || !((Component)val).gameObject.activeInHierarchy || ((Object)(object)viewport != (Object)null && ((Object)(object)val == (Object)(object)viewport || ((Transform)val).IsChildOf((Transform)(object)viewport))))
					{
						continue;
					}
					float rectBottomY = GetRectBottomY(val);
					float rectTopY = GetRectTopY(val);
					if (rectTopY - rectBottomY >= 30f && rectBottomY <= pageBottom + 30f)
					{
						float num = rectTopY - pageBottom + 48f;
						if (num > bestClearance && num < 250f)
						{
							bestClearance = num;
						}
					}
					ConsiderBottomUi(val, viewport, pageBottom, ref bestClearance);
				}
			}

			private static float ComputeMaxScroll(float viewportHeight, float contentExtent, float bottomClearance)
			{
				float num = Mathf.Max(100f, viewportHeight - bottomClearance);
				return Mathf.Max(0f, contentExtent - num + 85f);
			}
		}

		internal const float DefaultNavTopInset = 90f;

		internal const float DefaultBottomInset = 100f;

		internal const float MinScrollViewportHeight = 100f;

		internal const float ScrollBottomSlack = 85f;

		internal const float BottomUiMargin = 48f;

		internal const float ExtraBottomScrollLift = 50f;

		internal const float WheelScrollPixels = 90f;

		internal const string BaseScrollInnerName = "BaseScrollInner";

		internal const string StatsScrollInnerName = "StatsScrollInner";

		internal const string BaseClipViewportName = "BaseClipViewport";

		internal const string StatsClipViewportName = "StatsClipViewport";

		internal const string BaseNavCoverName = "BaseNavCover";

		internal const string StatsNavCoverName = "StatsNavCover";

		private static readonly Dictionary<int, Vector2> VanillaAnchoredPositions = new Dictionary<int, Vector2>();

		internal static void StripInnerLayoutComponents(RectTransform inner)
		{
			if (!((Object)(object)inner == (Object)null))
			{
				VerticalLayoutGroup component = ((Component)inner).GetComponent<VerticalLayoutGroup>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				ContentSizeFitter component2 = ((Component)inner).GetComponent<ContentSizeFitter>();
				if ((Object)(object)component2 != (Object)null)
				{
					Object.Destroy((Object)(object)component2);
				}
			}
		}

		internal static void EnsureInnerFillsViewportWidth(RectTransform viewport, RectTransform inner)
		{
			//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)
			if (!((Object)(object)viewport == (Object)null) && !((Object)(object)inner == (Object)null))
			{
				ForceLayoutChain(viewport);
				LayoutElement val = ((Component)inner).GetComponent<LayoutElement>();
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)inner).gameObject.AddComponent<LayoutElement>();
				}
				val.flexibleWidth = 1f;
				LayoutElement obj = val;
				Rect rect = viewport.rect;
				obj.minWidth = Mathf.Max(((Rect)(ref rect)).width, 100f);
			}
		}

		internal static void ForceViewportChildAlignmentUpperLeft(RectTransform viewport)
		{
			if (!((Object)(object)viewport == (Object)null))
			{
				VerticalLayoutGroup component = ((Component)viewport).GetComponent<VerticalLayoutGroup>();
				if ((Object)(object)component != (Object)null)
				{
					ForceChildAlignmentUpperLeft((HorizontalOrVerticalLayoutGroup)(object)component);
				}
			}
		}

		private static void ForceChildAlignmentUpperLeft(HorizontalOrVerticalLayoutGroup layoutGroup)
		{
			if (!((Object)(object)layoutGroup == (Object)null))
			{
				PropertyInfo property = typeof(HorizontalOrVerticalLayoutGroup).GetProperty("childAlignment", BindingFlags.Instance | BindingFlags.Public);
				if (!(property == null))
				{
					object value = Enum.ToObject(property.PropertyType, 0);
					property.SetValue(layoutGroup, value);
				}
			}
		}

		internal static void CopyVerticalLayoutGroup(RectTransform source, RectTransform dest)
		{
			if ((Object)(object)source == (Object)null || (Object)(object)dest == (Object)null)
			{
				return;
			}
			VerticalLayoutGroup component = ((Component)source).GetComponent<VerticalLayoutGroup>();
			if (!((Object)(object)component == (Object)null))
			{
				VerticalLayoutGroup val = ((Component)dest).GetComponent<VerticalLayoutGroup>();
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)dest).gameObject.AddComponent<VerticalLayoutGroup>();
				}
				((LayoutGroup)val).padding = ((LayoutGroup)component).padding;
				((HorizontalOrVerticalLayoutGroup)val).spacing = ((HorizontalOrVerticalLayoutGroup)component).spacing;
				((HorizontalOrVerticalLayoutGroup)val).childControlWidth = ((HorizontalOrVerticalLayoutGroup)component).childControlWidth;
				((HorizontalOrVerticalLayoutGroup)val).childControlHeight = ((HorizontalOrVerticalLayoutGroup)component).childControlHeight;
				((HorizontalOrVerticalLayoutGroup)val).childForceExpandWidth = ((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth;
				((HorizontalOrVerticalLayoutGroup)val).childForceExpandHeight = ((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight;
				CopyChildAlignment((HorizontalOrVerticalLayoutGroup)(object)component, (HorizontalOrVerticalLayoutGroup)(object)val);
				if ((Object)(object)((Component)dest).GetComponent<ContentSizeFitter>() == (Object)null)
				{
					ContentSizeFitter obj = ((Component)dest).gameObject.AddComponent<ContentSizeFitter>();
					obj.horizontalFit = (FitMode)0;
					obj.verticalFit = (FitMode)2;
				}
			}
		}

		internal static void AlignInnerContainerTopLeft(RectTransform inner)
		{
			//IL_0015: 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_003f: 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_0055: 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_0070: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)inner == (Object)null))
			{
				inner.anchorMin = new Vector2(0f, 1f);
				inner.anchorMax = new Vector2(1f, 1f);
				inner.pivot = new Vector2(0f, 1f);
				inner.anchoredPosition = Vector2.zero;
				inner.sizeDelta = Vector2.zero;
				inner.offsetMin = new Vector2(0f, inner.offsetMin.y);
				inner.offsetMax = new Vector2(0f, inner.offsetMax.y);
			}
		}

		private static void CopyChildAlignment(HorizontalOrVerticalLayoutGroup source, HorizontalOrVerticalLayoutGroup dest)
		{
			if (!((Object)(object)source == (Object)null) && !((Object)(object)dest == (Object)null))
			{
				PropertyInfo property = typeof(HorizontalOrVerticalLayoutGroup).GetProperty("childAlignment", BindingFlags.Instance | BindingFlags.Public);
				if (!(property == null))
				{
					property.SetValue(dest, property.GetValue(source));
				}
			}
		}

		internal static bool EnsureSetup(RectTransform content, Transform pageRoot, Config config, string logPrefix)
		{
			if ((Object)(object)content == (Object)null || config == null || config.IsScrollRow == null)
			{
				return false;
			}
			if (((Transform)content).childCount <= 0)
			{
				return false;
			}
			try
			{
				CleanupLegacyScrollArtifacts(pageRoot, content, config);
				UnitEditorContentScroller unitEditorContentScroller = ((Component)content).GetComponent<UnitEditorContentScroller>();
				if ((Object)(object)unitEditorContentScroller == (Object)null)
				{
					unitEditorContentScroller = ((Component)content).gameObject.AddComponent<UnitEditorContentScroller>();
				}
				if (!unitEditorContentScroller.Configure(content, pageRoot, config))
				{
					RollbackToVanillaLayout(content, config);
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				Plugin.LogWarning(logPrefix + ": EnsureSetup failed: " + ex.Message);
				return false;
			}
		}

		internal static void CleanupLegacyScrollArtifacts(Transform pageRoot, RectTransform contentParent, Config config)
		{
			if (!((Object)(object)contentParent == (Object)null) && config != null)
			{
				RectMask2D component = ((Component)contentParent).GetComponent<RectMask2D>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				DestroyLegacyDirectScrollComponents(contentParent);
				DestroyNamedChild((Transform)(object)contentParent, config.NavCoverName);
				if ((Object)(object)pageRoot != (Object)null)
				{
					DestroyNamedChild(pageRoot, config.NavCoverName);
				}
				UnitEditorUIManager val = ((pageRoot != null) ? ((Component)pageRoot).GetComponentInParent<UnitEditorUIManager>() : null);
				if ((Object)(object)val != (Object)null)
				{
					DestroyNamedChild(((Component)val).transform, config.NavCoverName);
				}
				if ((Object)(object)((Transform)contentParent).parent != (Object)null && ((Object)((Transform)contentParent).parent).name == config.ClipViewportName)
				{
					UnwrapLegacyContainer(((Transform)contentParent).parent);
				}
				Transform val2 = ((Transform)contentParent).Find(config.ClipViewportName);
				if ((Object)(object)val2 != (Object)null)
				{
					UnwrapLegacyContainer(val2);
				}
				UnwrapInnerContainer(contentParent, config);
			}
		}

		private static void UnwrapInnerContainer(RectTransform contentParent, Config config)
		{
			if ((Object)(object)contentParent == (Object)null || config == null || string.IsNullOrEmpty(config.InnerContainerName))
			{
				return;
			}
			Transform val = ((Transform)contentParent).Find(config.InnerContainerName);
			if (!((Object)(object)val == (Object)null))
			{
				ReparentPreservingOrder(val, (Transform)(object)contentParent, (Transform _) => true);
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
		}

		internal static void RollbackToVanillaLayout(RectTransform contentParent, Config config)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)contentParent == (Object)null || config == null)
			{
				return;
			}
			RectMask2D component = ((Component)contentParent).GetComponent<RectMask2D>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			DestroyLegacyDirectScrollComponents(contentParent);
			Transform parent = ((Transform)contentParent).parent;
			if ((Object)(object)parent != (Object)null && ((Object)parent).name == config.ClipViewportName)
			{
				UnwrapLegacyContainer(parent);
			}
			UnwrapInnerContainer(contentParent, config);
			if (config.Mode == ScrollMode.DirectContentY)
			{
				int instanceID = ((Object)contentParent).GetInstanceID();
				if (VanillaAnchoredPositions.TryGetValue(instanceID, out var value))
				{
					contentParent.anchoredPosition = value;
				}
				VanillaAnchoredPositions.Remove(instanceID);
			}
			else
			{
				Transform val = ((Transform)contentParent).Find(config.InnerContainerName);
				if ((Object)(object)val != (Object)null)
				{
					ReparentPreservingOrder(val, (Transform)(object)contentParent, (Transform _) => true);
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			UnitEditorContentScroller component2 = ((Component)contentParent).GetComponent<UnitEditorContentScroller>();
			if ((Object)(object)component2 != (Object)null)
			{
				Object.Destroy((Object)(object)component2);
			}
		}

		internal static void ResetScrollState(RectTransform content, Config config)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)content == (Object)null || config == null)
			{
				return;
			}
			if (config.Mode == ScrollMode.DirectContentY)
			{
				int instanceID = ((Object)content).GetInstanceID();
				if (VanillaAnchoredPositions.TryGetValue(instanceID, out var value))
				{
					content.anchoredPosition = value;
				}
			}
			((Component)content).GetComponent<UnitEditorContentScroller>()?.ResetScrollOffset();
		}

		internal static bool TryFastReopen(RectTransform content, Config config)
		{
			if ((Object)(object)content == (Object)null || config == null)
			{
				return false;
			}
			UnitEditorContentScroller component = ((Component)content).GetComponent<UnitEditorContentScroller>();
			if ((Object)(object)component == (Object)null || !component.IsConfiguredFor(config))
			{
				return false;
			}
			component.ResetScrollOffset();
			component.RefreshScrollMetrics();
			return true;
		}

		internal static RectTransform ResolveContentRect(Transform contentParent)
		{
			if ((Object)(object)contentParent == (Object)null)
			{
				return null;
			}
			RectTransform val = (RectTransform)(object)((contentParent is RectTransform) ? contentParent : null);
			if (val != null)
			{
				return val;
			}
			return ((Component)contentParent).GetComponent<RectTransform>();
		}

		internal static void ForceLayoutChain(RectTransform root)
		{
			Canvas.ForceUpdateCanvases();
			LayoutRebuilder.ForceRebuildLayoutImmediate(root);
			Transform parent = ((Transform)root).parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			if ((Object)(object)val != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(val);
			}
		}

		internal static void PrepareSharedViewport(RectTransform content)
		{
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)content == (Object)null))
			{
				UnitEditorContentScroller component = ((Component)content).GetComponent<UnitEditorContentScroller>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				RectMask2D component2 = ((Component)content).GetComponent<RectMask2D>();
				if ((Object)(object)component2 != (Object)null)
				{
					Object.Destroy((Object)(object)component2);
				}
				DestroyLegacyDirectScrollComponents(content);
				if ((Object)(object)((Transform)content).parent != (Object)null && ((Object)((Transform)content).parent).name == "BaseClipViewport")
				{
					UnwrapLegacyContainer(((Transform)content).parent);
				}
				if ((Object)(object)((Transform)content).parent != (Object)null && ((Object)((Transform)content).parent).name == "StatsClipViewport")
				{
					UnwrapLegacyContainer(((Transform)content).parent);
				}
				Transform val = ((Transform)content).Find("BaseClipViewport");
				if ((Object)(object)val != (Object)null)
				{
					UnwrapLegacyContainer(val);
				}
				Transform val2 = ((Transform)content).Find("StatsClipViewport");
				if ((Object)(object)val2 != (Object)null)
				{
					UnwrapLegacyContainer(val2);
				}
				DestroyNamedChild((Transform)(object)content, "BaseNavCover");
				DestroyNamedChild((Transform)(object)content, "StatsNavCover");
				UnwrapNamedInner(content, "BaseScrollInner");
				UnwrapNamedInner(content, "StatsScrollInner");
				int instanceID = ((Object)content).GetInstanceID();
				if (VanillaAnchoredPositions.TryGetValue(instanceID, out var value))
				{
					content.anchoredPosition = value;
				}
				ForceLayoutChain(content);
			}
		}

		private static void UnwrapNamedInner(RectTransform contentParent, string innerName)
		{
			if ((Object)(object)contentParent == (Object)null || string.IsNullOrEmpty(innerName))
			{
				return;
			}
			Transform val = ((Transform)contentParent).Find(innerName);
			if (!((Object)(object)val == (Object)null))
			{
				ReparentPreservingOrder(val, (Transform)(object)contentParent, (Transform _) => true);
				Object.Destroy((Object)(object)((Component)val).gameObject);
			}
		}

		private static void DestroyLegacyDirectScrollComponents(RectTransform contentParent)
		{
			if ((Object)(object)contentParent == (Object)null)
			{
				return;
			}
			MonoBehaviour[] components = ((Component)contentParent).GetComponents<MonoBehaviour>();
			foreach (MonoBehaviour val in components)
			{
				if (!((Object)(object)val == (Object)null) && ((object)val).GetType().Name == "UnitEditorBaseContentScroller")
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		private static void DestroyNamedChild(Transform parent, string name)
		{
			if (!((Object)(object)parent == (Object)null) && !string.IsNullOrEmpty(name))
			{
				Transform val = parent.Find(name);
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
		}

		private static void ReparentPreservingOrder(Transform from, Transform to, Func<Transform, bool> shouldMove, bool preserveWorldPosition = false)
		{
			List<Transform> list = new List<Transform>();
			for (int i = 0; i < from.childCount; i++)
			{
				Transform child = from.GetChild(i);
				if (shouldMove == null || shouldMove(child))
				{
					list.Add(child);
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				list[j].SetParent(to, preserveWorldPosition);
				list[j].SetSiblingIndex(j);
			}
		}

		private static void UnwrapLegacyContainer(Transform clip)
		{
			if (!((Object)(object)((clip != null) ? clip.parent : null) == (Object)null))
			{
				ReparentPreservingOrder(clip, clip.parent, (Transform _) => true);
				Object.Destroy((Object)(object)((Component)clip).gameObject);
			}
		}
	}
	internal static class UnitEditorFootstepDebug
	{
		internal static void Log(string message)
		{
		}

		internal static void LogWarning(string message)
		{
		}
	}
	internal static class UnitEditorUiText
	{
		private static readonly FieldInfo LocaleIdField = AccessTools.Field(typeof(LocalizeText), "m_localeID");

		private static readonly MethodInfo UpdateTextMethod = AccessTools.Method(typeof(LocalizeText), "UpdateText", (Type[])null, (Type[])null);

		internal static string GetLocaleId(LocalizeText localize)
		{
			if ((Object)(object)localize == (Object)null)
			{
				return string.Empty;
			}
			return (LocaleIdField?.GetValue(localize) as string) ?? string.Empty;
		}

		internal static void SetRawLocalizeText(LocalizeText localize, string display)
		{
			if ((Object)(object)localize == (Object)null)
			{
				UnitEditorFootstepDebug.LogWarning("SetRawLocalizeText: localize is null (wanted \"" + display + "\")");
				return;
			}
			localize.Localized = false;
			localize.LocaleID = display ?? string.Empty;
			UpdateTextMethod?.Invoke(localize, null);
		}

		internal static string GetLocalizeDisplayText(LocalizeText localize)
		{
			if ((Object)(object)localize == (Object)null)
			{
				return string.Empty;
			}
			object obj = typeof(LocalizeText).GetProperty("Text")?.GetValue(localize);
			if (obj == null)
			{
				return string.Empty;
			}
			return (obj.GetType().GetProperty("text")?.GetValue(obj) as string) ?? string.Empty;
		}

		internal static float GetLocalizeFontSize(LocalizeText localize)
		{
			if ((Object)(object)localize == (Object)null)
			{
				return 0f;
			}
			object obj = typeof(LocalizeText).GetProperty("Text")?.GetValue(localize);
			if (obj == null)
			{
				return 0f;
			}
			object obj2 = obj.GetType().GetProperty("fontSize")?.GetValue(obj);
			if (obj2 is float)
			{
				return (float)obj2;
			}
			return 0f;
		}

		internal static string GetTransformPath(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return "(null)";
			}
			string text = ((Object)transform).name;
			Transform parent = transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}

		internal static void ReplaceButtonClick(Button button, UnityAction action)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (!((Object)(object)button == (Object)null) && action != null)
			{
				button.onClick = new ButtonClickedEvent();
				((UnityEvent)button.onClick).AddListener(action);
			}
		}
	}
	internal sealed class FootstepRowMarker : MonoBehaviour
	{
	}
	internal sealed class FootstepRowUi : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DeferredRefreshRoutine>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public FootstepRowUi <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DeferredRefreshRoutine>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				int num = <>1__state;
				FootstepRowUi footstepRowUi = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					UnitEditorFootstepDebug.Log("DeferredRefresh: rediscovering text/icon refs after LocalizeText.Start");
					if ((Object)(object)footstepRowUi.VoiceItem != (Object)null)
					{
						footstepRowUi.DiscoverReferences(footstepRowUi.VoiceItem, textAndIconOnly: true);
					}
					UnitEditorCustomFootsteps.RefreshFootstepRowUi();
					footstepRowUi._deferredRefreshScheduled = false;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		internal LocalizeText SectionHeaderText;

		internal LocalizeText InlineHeaderText;

		internal LocalizeText SelectionText;

		internal Image SelectionIcon;

		internal Slider PitchSlider;

		internal Button PreviewButton;

		internal UnitEditorSelectableVoiceItem VoiceItem;

		private bool _deferredRefreshScheduled;

		internal void BindSectionHeader(LocalizeText sectionHeader)
		{
			SectionHeaderText = sectionHeader;
		}

		internal void DiscoverReferences(UnitEditorSelectableVoiceItem voiceItem, bool textAndIconOnly = false)
		{
			VoiceItem = voiceItem;
			if (!textAndIconOnly)
			{
				ref Slider pitchSlider = ref PitchSlider;
				object? obj = AccessTools.Field(typeof(UnitEditorSelectableVoiceItem), "pitchSlider")?.GetValue(voiceItem);
				pitchSlider = (Slider)((obj is Slider) ? obj : null);
				ref Button previewButton = ref PreviewButton;
				object? obj2 = AccessTools.Field(typeof(UnitEditorSelectableVoiceItem), "previewButton")?.GetValue(voiceItem);
				previewButton = (Button)((obj2 is Button) ? obj2 : null);
			}
			InlineHeaderText = null;
			SelectionText = null;
			SelectionIcon = null;
			SelectionText = FindNamedLocalizeText(((Component)this).transform, "UnitVoiceName");
			SelectionIcon = FindNamedImage(((Component)this).transform, "UnitVoiceIcon") ?? FindSelectionIconFallback();
			LocalizeText[] componentsInChildren = ((Component)this).GetComponentsInChildren<LocalizeText>(true);
			UnitEditorFootstepDebug.Log($"DiscoverReferences on {((Object)this).name}: {componentsInChildren.Length} LocalizeText child(ren)");
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				LocalizeText val = componentsInChildren[i];
				string localeId = UnitEditorUiText.GetLocaleId(val);
				string localizeDisplayText = UnitEditorUiText.GetLocalizeDisplayText(val);
				string transformPath = UnitEditorUiText.GetTransformPath(((Component)val).transform);
				UnitEditorFootstepDebug.Log($"  [{i}] path={transformPath} localeId=\"{localeId}\" display=\"{localizeDisplayText}\"");
				if (!IsPitchLabel(localeId, localizeDisplayText) && IsInlineHeader(localeId, localizeDisplayText))
				{
					InlineHeaderText = val;
				}
			}
			if ((Object)(object)SelectionIcon == (Object)null)
			{
				SelectionIcon = FindSelectionIconFallback();
			}
			UnitEditorFootstepDebug.Log($"DiscoverReferences result: SectionHeader={(Object)(object)SectionHeaderText != (Object)null} InlineHeader={(Object)(object)InlineHeaderText != (Object)null} " + "SelectionText=" + (((Object)(object)SelectionText != (Object)null) ? UnitEditorUiText.GetTransformPath(((Component)SelectionText).transform) : "null") + ", SelectionIcon=" + (((Object)(object)SelectionIcon != (Object)null) ? ((Object)SelectionIcon).name : "null") + ", PitchSlider=" + (((Object)(object)PitchSlider != (Object)null) ? ((Object)PitchSlider).name : "null") + ", PreviewButton=" + (((Object)(object)PreviewButton != (Object)null) ? ((Object)PreviewButton).name : "null"));
		}

		internal void ScheduleDeferredRefresh()
		{
			if (!_deferredRefreshScheduled)
			{
				_deferredRefreshScheduled = true;
				((MonoBehaviour)this).StartCoroutine(DeferredRefreshRoutine());
			}
		}

		[IteratorStateMachine(typeof(<DeferredRefreshRoutine>d__11))]
		private IEnumerator DeferredRefreshRoutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DeferredRefreshRoutine>d__11(0)
			{
				<>4__this = this
			};
		}

		private static LocalizeText FindNamedLocalizeText(Transform root, string targetName)
		{
			Transform val = FindTransformByName(root, targetName);
			if (!((Object)(object)val != (Object)null))
			{
				return null;
			}
			return ((Component)val).GetComponent<LocalizeText>();
		}

		private static Image FindNamedImage(Transform root, string targetName)
		{
			Transform val = FindTransformByName(root, targetName);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			return ((Component)val).GetComponent<Image>() ?? ((Component)val).GetComponentInChildren<Image>(true);
		}

		private Image FindSelectionIconFallback()
		{
			//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)
			string[] array = new string[3] { "UnitVoiceName", "Icon", "VoiceIcon" };
			for (int i = 0; i < array.Length; i++)
			{
				Transform val = FindTransformByName(((Component)this).transform, array[i]);
				if (!((Object)(object)val == (Object)null))
				{
					Image val2 = ((Component)val).GetComponent<Image>() ?? ((Component)val).GetComponentInChildren<Image>(true);
					if ((Object)(object)val2 != (Object)null && !IsExcludedImage(val2))
					{
						return val2;
					}
				}
			}
			Image result = null;
			float num = float.MaxValue;
			Image[] componentsInChildren = ((Component)this).GetComponentsInChildren<Image>(true);
			foreach (Image val3 in componentsInChildren)
			{
				if (!((Object)(object)val3 == (Object)null) && !IsExcludedImage(val3) && !((Object)(object)val3.sprite == (Object)null))
				{
					Rect rect = ((Graphic)val3).rectTransform.rect;
					float num2 = ((Rect)(ref rect)).width * ((Rect)(ref rect)).height;
					if (!(num2 <= 0f) && !(num2 >= num))
					{
						num = num2;
						result = val3;
					}
				}
			}
			return result;
		}

		private static Transform FindTransformByName(Transform root, string targetName)
		{
			if (((Object)root).name.IndexOf(targetName, StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return root;
			}
			for (int i = 0; i < root.childCount; i++)
			{
				Transform val = FindTransformByName(root.GetChild(i), targetName);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private bool IsExcludedImage(Image image)
		{
			if ((Object)(object)PreviewButton != (Object)null && ((Component)image).transform.IsChildOf(((Component)PreviewButton).transform))
			{
				return true;
			}
			if ((Object)(object)PitchSlider != (Object)null && ((Component)image).transform.IsChildOf(((Component)PitchSlider).transform))
			{
				return true;
			}
			string name = ((Object)image).name;
			if (name.IndexOf("BG", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.IndexOf("Background", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static bool IsPitchLabel(string localeId, string display)
		{
			if (localeId.IndexOf("PITCH", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return display.IndexOf("PITCH", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static bool IsInlineHeader(string localeId, string display)
		{
			if (localeId.IndexOf("UNITVOICE", StringComparison.OrdinalIgnoreCase) < 0 && localeId.IndexOf("UNITFOOTSTEP", StringComparison.OrdinalIgnoreCase) < 0 && display.IndexOf("unit voice", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return display.IndexOf("unit footstep", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}
	}
	internal static class UnitEditorCustomFootsteps
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__Open;

			public static UnityAction <1>__PreviewCurrentFootstep;
		}

		[CompilerGenerated]
		private sealed class <DeferredCreateFootstepRow>d__44 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public UnitEditorBasePageUI basePage;

			public UnitEditorSelectableVoiceItem voiceSelect;

			public Transform contentParent;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DeferredCreateFootstepRow>d__44(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					_createFootstepRowCoroutine = null;
					if ((Object)(object)basePage == (Object)null || (Object)(object)voiceSelect == (Object)null || (Object)(object)contentParent == (Object)null)
					{
						return false;
					}
					if (!UnitEditorConfig.CustomFootstepsEnabled)
					{
						return false;
					}
					if ((Object)(object)_footstepRow != (Object)null && (Object)(object)((Component)_footstepRow).gameObject != (Object)null)
					{
						RefreshFootstepRowUi();
						UnitEditorBasePageScroll.ScheduleSetup(basePage);
						return false;
					}
					FootstepIconResolver.WarmCache();
					UnitEditorFootstepDebug.Log("EnsureFootstepRow: cloning voiceSelect at " + UnitEditorUiText.GetTransformPath(((Component)voiceSelect).transform));
					GameObject val = null;
					GameObject val2 = null;
					try
					{
						val = TryCloneSectionHeader(voiceSelect);
						val2 = Object.Instantiate<GameObject>(((Component)voiceSelect).gameObject, ((Component)voiceSelect).transform.parent);
						((Object)val2).name = "StayCombatFix_FootstepRow";
						UnitEditorCustomVoiceButton.StripFromTransform(val2.transform);
						int num = ((Component)voiceSelect).transform.GetSiblingIndex() + 1;
						if ((Object)(object)val != (Object)null)
						{
							val.transform.SetSiblingIndex(num);
							num++;
						}
						val2.transform.SetSiblingIndex(num);
						UnitEditorSelectableVoiceItem component = val2.GetComponent<UnitEditorSelectableVoiceItem>();
						if ((Object)(object)component == (Object)null)
						{
							throw new InvalidOperationException("cloned row missing UnitEditorSelectableVoiceItem");
						}
						val2.AddComponent<FootstepRowMarker>();
						FootstepRowUi footstepRowUi = val2.GetComponent<FootstepRowUi>();
						if ((Object)(object)footstepRowUi == (Object)null)
						{
							footstepRowUi = val2.AddComponent<FootstepRowUi>();
						}
						LocalizeText sectionHeader = (((Object)(object)val != (Object)null) ? (val.GetComponent<LocalizeText>() ?? val.GetComponentInChildren<LocalizeText>(true)) : null);
						footstepRowUi.BindSectionHeader(sectionHeader);
						footstepRowUi.DiscoverReferences(component);
						WireFootstepRow(footstepRowUi, component);
						_footstepRow = footstepRowUi;
						RefreshFootstepRowUi();
						footstepRowUi.ScheduleDeferredRefresh();
						RefreshNavigation(basePage);
						UnitEditorBasePageScroll.ScheduleSetup(basePage);
						UnitEditorFootstepDebug.Log("EnsureFootstepRow: created StayCombatFix_FootstepRow");
					}
					catch (Exception ex)
					{
						UnitEditorFootstepDebug.LogWarning("EnsureFootstepRow failed: " + ex.Message);
						Plugin.LogWarning("Unit footstep row setup failed: " + ex.Message);
						if ((Object)(object)val2 != (Object)null)
						{
							Object.Destroy((Object)(object)val2);
						}
						if ((Object)(object)val != (Object)null)
						{
							Object.Destroy((Object)(object)val);
						}
						_footstepRow = null;
					}
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private const string FootstepRowName = "StayCombatFix_FootstepRow";

		private const string FootstepHeaderName = "StayCombatFix_FootstepHeader";

		private const float PitchIncrement = 0.1f;

		private static readonly FieldInfo VoiceSelectField = AccessTools.Field(typeof(UnitEditorBasePageUI), "voiceSelect");

		private static readonly FieldInfo EditorUnitBasesField = AccessTools.Field(typeof(UnitEditorManager), "UnitBases");

		private static readonly FieldInfo EditorCurrentUnitBaseField = AccessTools.Field(typeof(UnitEditorManager), "currentUnitBase");

		private static readonly FieldInfo EditorSpawnedBaseField = AccessTools.Field(typeof(UnitEditorManager), "spawnedBase");

		private static readonly MethodInfo EditorRespawnUnitMethod = AccessTools.Method(typeof(UnitEditorManager), "RespawnUnit", (Type[])null, (Type[])null);

		private static readonly FieldInfo EditorLoadedUnitField = AccessTools.Field(typeof(UnitEditorManager), "loadedUnit");

		private static readonly MethodInfo GetUnitDescriptionMethod = AccessTools.Method(typeof(UnitEditorUIManager), "GetUnitDescrption", (Type[])null, (Type[])null);

		private static readonly MethodInfo SetUnitDescriptionMethod = AccessTools.Method(typeof(UnitEditorUIManager), "SetDescription", (Type[])null, (Type[])null);

		private static readonly FieldInfo ContentParentField = AccessTools.Field(typeof(UnitEditorBasePageUI), "contentParent");

		private static readonly FieldInfo SubmitEventField = AccessTools.Field(typeof(UnitEditorSelectableItem), "onSubmitEvent");

		private static readonly FieldInfo CorrespondingButtonField = AccessTools.Field(typeof(UnitEditorSelectableItem), "correspondingButton");

		private static readonly MethodInfo CreateExplicitLinearNavigationMethod = AccessTools.Method(AccessTools.TypeByName("UIHelpers"), "CreateExplicitLinearNavigation", (Type[])null, (Type[])null);

		private static readonly MethodInfo GetSelectableChildrenMethod = AccessTools.Method(AccessTools.TypeByName("UIHelpers"), "GetSelectableChildren", new Type[2]
		{
			typeof(Transform),
			typeof(bool)
		}, (Type[])null);

		private static FootstepRowUi _footstepRow;

		private static Coroutine _createFootstepRowCoroutine;

		private static string _currentFootRef = "Footsteps/Normal";

		private static float _currentFootPitch = 1f;

		internal static string CurrentFootRef => _currentFootRef;

		internal static float GetCurrentFootPitch()
		{
			if ((Object)(object)_footstepRow?.PitchSlider != (Object)null)
			{
				return _footstepRow.PitchSlider.value;
			}
			return _currentFootPitch;
		}

		internal static void SetCurrentFootstep(FootstepDef def)
		{
			if (def != null)
			{
				_currentFootRef = def.AudioRef;
				UnitEditorFootstepDebug.Log("SetCurrentFootstep: " + _currentFootRef + " (" + def.DisplayName + ")");
				ApplyFootstepToEditorSpawnBlueprint();
				StripFootstepMetadataFromDescriptionField();
				RefreshFootstepRowUi();
				_footstepRow?.ScheduleDeferredRefresh();
			}
		}

		internal static void ApplyFootstepToEditorSpawnBlueprint(bool respawn = true)
		{
			if (UnitEditorConfig.CustomFootstepsEnabled && TryGetEditorSpawnBlueprint(out var manager, out var blueprint))
			{
				float currentFootPitch = GetCurrentFootPitch();
				FootstepBlueprintHelper.SetFootRef(blueprint, _currentFootRef);
				FootstepBlueprintHelper.SetFootPitch(blueprint, currentFootPitch);
				object? obj = EditorLoadedUnitField?.GetValue(manager);
				UnitBlueprint val = (UnitBlueprint)((obj is UnitBlueprint) ? obj : null);
				if (val != null && (Object)(object)val != (Object)null)
				{
					FootstepBlueprintHelper.SetFootRef(val, _currentFootRef);
					FootstepBlueprintHelper.SetFootPitch(val, currentFootPitch);
				}
				if (respawn)
				{
					EditorRespawnUnitMethod?.Invoke(manager, null);
					UnitEditorFootstepDebug.Log($"ApplyFootstepToEditorSpawnBlueprint: respawned footRef={_currentFootRef} pitch={GetCurrentFootPitch():0.##}");
				}
				else
				{
					SyncLiveUnitFootSounds(manager, blueprint);
					UnitEditorFootstepDebug.Log($"ApplyFootstepToEditorSpawnBlueprint: synced live footRef={_currentFootRef} pitch={GetCurrentFootPitch():0.##}");
				}
			}
		}

		internal static void ApplyFromBlueprint(UnitBlueprint blueprint)
		{
			if (!((Object)(object)blueprint == (Object)null))
			{
				_currentFootRef = FootstepBlueprintHelper.GetFootRef(blueprint);
				_currentFootPitch = FootstepBlueprintHelper.GetFootPitch(blueprint);
				RefreshFootstepRowUi();
			}
		}

		internal static void ResetToDefaults()
		{
			_currentFootRef = "Footsteps/Normal";
			_currentFootPitch = 1f;
			RefreshFootstepRowUi();
		}

		internal static void PreviewCurrentFootstep()
		{
			FootstepBlueprintHelper.PlayPreviewSound(FootstepCatalog.GetByAudioRef(_currentFootRef).AudioRef, GetCurrentFootPitch());
		}

		public static bool PreviewVoice_Prefix(UnitEditorSelectableVoiceItem __instance)
		{
			if (!UnitEditorConfig.CustomFootstepsEnabled)
			{
				return true;
			}
			if ((Object)(object)((Component)__instance).GetComponent<FootstepRowMarker>() == (Object)null)
			{
				return true;
			}
			PreviewCurrentFootstep();
			return false;
		}

		public static void ClearUnit_Postfix()
		{
			if (UnitEditorConfig.CustomFootstepsEnabled)
			{
				ResetToDefaults();
			}
		}

		public static void BasePage_Open_Postfix(UnitEditorBasePageUI __instance)
		{
			if (!UnitEditorConfig.CustomFootstepsEnabled)
			{
				object? obj = ContentParentField?.GetValue(__instance);
				Transform val = (Transform)((obj is Transform) ? obj : null);
				if (val != null)
				{
					CleanupFootstepUi(val);
				}
				_footstepRow = null;
				UnitEditorBasePageScroll.Cleanup(__instance, fullRollback: true);
			}
			else
			{
				UnitEditorFootstepDebug.Log("BasePage_Open_Postfix fired");
				EnsureFootstepRow(__instance);
			}
		}

		public static void BasePage_Close_Postfix(UnitEditorBasePageUI __instance)
		{
			UnitEditorBasePageScroll.Cleanup(__instance);
		}

		public static void UIManager_Start_Prefix(UnitEditorUIManager __instance)
		{
			if (!UnitEditorConfig.CustomFootstepsEnabled)
			{
				return;
			}
			_footstepRow = null;
			UnitEditorBasePageUI val = Object.FindObjectOfType<UnitEditorBasePageUI>();
			if ((Object)(object)val != (Object)null)
			{
				UnitEditorBasePageScroll.Cleanup(val, fullRollback: true);
				object? obj = ContentParentField?.GetValue(val);
				Transform val2 = (Transform)((obj is Transform) ? obj : null);
				if (val2 != null)
				{
					CleanupFootstepUi(val2);
				}
			}
		}

		public static void LoadUnit_Postfix(UnitEditorManager __instance, UnitBlueprint blueprint)
		{
			if (UnitEditorConfig.CustomFootstepsEnabled && !((Object)(object)blueprint == (Object)null))
			{
				ApplyFromBlueprint(blueprint);
				ApplyFootstepToEditorSpawnBlueprint();
				string text = FootstepMetadata.Strip(blueprint.UnitDescription);
				if (!string.Equals(text, blueprint.UnitDescription, StringComparison.Ordinal))
				{
					blueprint.UnitDescription = text;
				}
				UnitEditorUIManager uIManager = __instance.UIManager;
				if (uIManager != null)
				{
					uIManager.SetDescription(text);
				}
			}
		}

		public static void GetBlueprint_Postfix(UnitEditorManager __instance, ref UnitBlueprint __result)
		{
			if (UnitEditorConfig.CustomFootstepsEnabled && !((Object)(object)__result == (Object)null))
			{
				FootstepBlueprintHelper.SetFootRef(__result, _currentFootRef);
				FootstepBlueprintHelper.SetFootPitch(__result, GetCurrentFootPitch());
				__result.UnitDescription = FootstepMetadata.Strip(__result.UnitDescription);
			}
		}

		public static void SwitchUnitBase_Postfix(UnitEditorManager __instance)
		{
			if (!UnitEditorConfig.CustomFootstepsEnabled || (Object)(object)__instance == (Object)null || AccessTools.Field(typeof(UnitEditorManager), "loadedUnit")?.GetValue(__instance) != null)
			{
				return;
			}
			FieldInfo fieldInfo = AccessTools.Field(typeof(UnitEditorManager), "UnitBases");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(UnitEditorManager), "currentUnitBase");
			if (!(fieldInfo?.GetValue(__instance) is UnitBaseWrapper[] array))
			{
				return;
			}
			object obj = fieldInfo2?.GetValue(__instance);
			if (!(obj is int))
			{
				return;
			}
			int num = (int)obj;
			if (num >= 0 && num < array.Length)
			{
				UnitBlueprint unitBaseBlueprint = array[num].UnitBaseBlueprint;
				if (!((Object)(object)unitBaseBlueprint == (Object)null))
				{
					ApplyFromBlueprint(unitBaseBlueprint);
					ApplyFootstepToEditorSpawnBlueprint();
				}
			}
		}

		public static void RespawnUnit_Postfix(UnitEditorManager __instance)
		{
			if (!UnitEditorConfig.CustomFootstepsEnabled || (Object)(object)__instance == (Object)null || !(EditorUnitBasesField?.GetValue(__instance) is UnitBaseWrapper[] array))
			{
				return;
			}
			object obj = EditorCurrentUnitBaseField?.GetValue(__instance);
			if (!(obj is int))
			{
				return;
			}
			int num = (int)obj;
			if (num >= 0 && num < array.Length)
			{
				UnitBlueprint unitBaseBlueprint = array[num].UnitBaseBlueprint;
				if (!((Object)(object)unitBaseBlueprint == (Object)null))
				{
					FootstepBlueprintHelper.SetFootRef(unitBaseBlueprint, _currentFootRef);
					FootstepBlueprintHelper.SetFootPitch(unitBaseBlueprint, GetCurrentFootPitch());
					SyncLiveUnitFootSounds(__instance, unitBaseBlueprint);
					UnitEditorFootstepDebug.Log($"RespawnUnit_Postfix: synced footRef={_currentFootRef} pitch={GetCurrentFootPitch():0.##}");
				}
			}
		}

		public static void EquipedVoiceBundle_Postfix()
		{
			if (UnitEditorConfig.CustomFootstepsEnabled && !((Object)(object)_footstepRow == (Object)null) && !((Object)(object)((Component)_footstepRow).gameObject == (Object)null))
			{
				RefreshFootstepRowUi();
			}
		}

		public static void SerializedUnit_Postfix(UnitBlueprint __instance, ref SerializedUnitBlueprint __result)
		{
			if (UnitEditorConfig.CustomFootstepsEnabled && !((Object)(object)__instance == (Object)null) && __result != null)
			{
				string effectId = FootstepCatalog.EffectIdFromAudioRef(FootstepBlueprintHelper.GetFootRef(__instance));
				float footPitch = FootstepBlueprintHelper.GetFootPitch(__instance);
				__result.unitDescription = FootstepMetadata.Embed(FootstepMetadata.Strip(__result.unitDescription), effectId);
				__result.voiceVolume = footPitch;
			}
		}

		public static void DeserializedUnit_Postfix(SerializedUnitBlueprint data, ref UnitBlueprint __result)
		{
			if (UnitEditorConfig.CustomFootstepsEnabled && data != null && !((Object)(object)__result == (Object)null))
			{
				float pitch = ((data.voiceVolume > 0f) ? data.voiceVolume : 1f);
				FootstepBlueprintHelper.SetFootPitch(__result, pitch);
				if (FootstepMetadata.TryParse(data.unitDescription, out var effectId, out var cleanDescription))
				{
					FootstepBlueprintHelper.SetFootRef(__result, FootstepCatalog.GetByEffectId(effectId).AudioRef);
					__result.UnitDescription = cleanDescription;
				}
				else
				{
					FootstepBlueprintHelper.SetFootRef(__result, "Footsteps/Normal");
				}
			}
		}

		public static bool PerformIncreaseAction_Prefix(UnitEditorBasePageUI __instance)
		{
			if (!UnitEditorConfig.CustomFootstepsEnabled || !IsFootstepRowSelected(__instance))
			{
				return true;
			}
			AdjustFootstepPitch(0.1f);
			return false;
		}

		public static bool PerformDecreaseAction_Prefix(UnitEditorBasePageUI __instance)
		{
			if (!UnitEditorConfig.CustomFootstepsEnabled || !IsFootstepRowSelected(__instance))
			{
				return true;
			}
			AdjustFootstepPitch(-0.1f);
			return false;
		}

		public static bool GoToVoiceSelect_Prefix()
		{
			if (!UnitEditorConfig.CustomFootstepsEnabled)
			{
				return true;
			}
			EventSystem current = EventSystem.current;
			GameObject val = ((current != null) ? current.currentSelectedGameObject : null);
			if ((Object)(object)val == (Object)null)
			{
				UnitEditorFootstepDebug.Log("GoToVoiceSelect_Prefix: no selected GO, allowing vanilla");
				return true;
			}
			if ((Object)(object)val.GetComponentInParent<FootstepRowMarker>() == (Object)null)
			{
				UnitEditorFootstepDebug.Log("GoToVoiceSelect_Prefix: selected=" + ((Object)val).name + ", not footstep row, allowing vanilla");
				return true;
			}
			UnitEditorFootstepDebug.Log("GoToVoiceSelect_Prefix: selected=" + ((Object)val).name + ", redirecting to footstep picker");
			UnitEditorFootstepPicker.Open();
			return false;
		}

		private static void EnsureFootstepRow(UnitEditorBasePageUI basePage)
		{
			object? obj = VoiceSelectField?.GetValue(basePage);
			UnitEditorSelectableVoiceItem val = (UnitEditorSelectableVoiceItem)((obj is UnitEditorSelectableVoiceItem) ? obj : null);
			if (val == null)
			{
				Plugin.LogWarning("Unit footstep row: voiceSelect not found");
				UnitEditorFootstepDebug.LogWarning("EnsureFootstepRow: voiceSelect field is null");
				return;
			}
			object? obj2 = ContentParentField?.GetValue(basePage);
			Transform val2 = (Transform)((obj2 is Transform) ? obj2 : null);
			if (val2 == null)
			{
				UnitEditorFootstepDebug.LogWarning("EnsureFootstepRow: contentParent is null");
				return;
			}
			if ((Object)(object)_footstepRow == (Object)null || (Object)(object)((Component)_footstepRow).gameObject == (Object)null)
			{
				_footstepRow = FindOrReuseFootstepRow(val2);
			}
			if ((Object)(object)_footstepRow != (Object)null)
			{
				UnitEditorFootstepDebug.Log("EnsureFootstepRow: reusing existing footstep row");
				RefreshFootstepRowUi();
				UnitEditorBasePageScroll.ScheduleSetup(basePage);
			}
			else if (!((Object)(object)Plugin.Instance == (Object)null))
			{
				if (_createFootstepRowCoroutine != null)
				{
					((MonoBehaviour)Plugin.Instance).StopCoroutine(_createFootstepRowCoroutine);
					_createFootstepRowCoroutine = null;
				}
				_createFootstepRowCoroutine = ((MonoBehaviour)Plugin.Instance).StartCoroutine(DeferredCreateFootstepRow(basePage, val, val2));
			}
		}

		[IteratorStateMachine(typeof(<DeferredCreateFootstepRow>d__44))]
		private static IEnumerator DeferredCreateFootstepRow(UnitEditorBasePageUI basePage, UnitEditorSelectableVoiceItem voiceSelect, Transform contentParent)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DeferredCreateFootstepRow>d__44(0)
			{
				basePage = basePage,
				voiceSelect = voiceSelect,
				contentParent = contentParent
			};
		}

		private static FootstepRowUi FindOrReuseFootstepRow(Transform contentParent)
		{
			CleanupFootstepUi(contentParent);
			FootstepRowUi result = null;
			for (int i = 0; i < contentParent.childCount; i++)
			{
				Transform child = contentParent.GetChild(i);
				if (!(((Object)child).name != "StayCombatFix_FootstepRow") && !((Object)(object)((Component)child).GetComponent<FootstepRowMarker>() == (Object)null))
				{
					FootstepRowUi component = ((Component)child).GetComponent<FootstepRowUi>();
					if (!((Object)(object)component == (Object)null))
					{
						result = component;
						break;
					}
				}
			}
			return result;
		}

		private static void CleanupFootstepUi(Transform contentParent)
		{
			if ((Object)(object)contentParent == (Object)null)
			{
				return;
			}
			FootstepRowUi footstepRowUi = null;
			List<GameObject> list = new List<GameObject>();
			List<GameObject> list2 = new List<GameObject>();
			for (int i = 0; i < contentParent.childCount; i++)
			{
				Transform child = contentParent.GetChild(i);
				if (((Object)child).name == "StayCombatFix_FootstepRow")
				{
					FootstepRowUi component = ((Component)child).GetComponent<FootstepRowUi>();
					FootstepRowMarker component2 = ((Component)child).GetComponent<FootstepRowMarker>();
					if ((Object)(object)footstepRowUi == (Object)null && (Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
					{
						footstepRowUi = component;
					}
					else
					{
						list.Add(((Component)child).gameObject);
					}
				}
				else if (((Object)child).name == "StayCombatFix_FootstepHeader")
				{
					list2.Add(((Component)child).gameObject);
				}
			}
			if ((Object)(object)footstepRowUi != (Object)null && list2.Count > 0)
			{
				GameObject val = (((Object)(object)footstepRowUi.SectionHeaderText != (Object)null) ? ((Component)footstepRowUi.SectionHeaderText).gameObject : null);
				for (int j = 0; j < list2.Count; j++)
				{
					if (!((Object)(object)val != (Object)null) || !((Object)(object)list2[j] == (Object)(object)val))
					{
						Object.Destroy((Object)(object)list2[j]);
					}
				}
			}
			else
			{
				for (int k = 0; k < list2.Count; k++)
				{
					Object.Destroy((Object)(object)list2[k]);
				}
			}
			for (int l = 0; l < list.Count; l++)
			{
				Object.Destroy((Object)(object)list[l]);
			}
		}

		private static GameObject TryCloneSectionHeader(UnitEditorSelectableVoiceItem voiceSelect)
		{
			Transform parent = ((Component)voiceSelect).transform.parent;
			if ((Object)(object)parent == (Object)null)
			{
				return null;
			}
			int siblingIndex = ((Component)voiceSelect).transform.GetSiblingIndex();
			if (siblingIndex <= 0)
			{
				return null;
			}
			Transform child = parent.GetChild(siblingIndex - 1);
			LocalizeText val = ((Component)child).GetComponent<LocalizeText>() ?? ((Component)child).GetComponentInChildren<LocalizeText>(true);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			string localeId = UnitEditorUiText.GetLocaleId(val);
			string localizeDisplayText = UnitEditorUiText.GetLocalizeDisplayText(val);
			if (localeId.IndexOf("VOICE", StringComparison.OrdinalIgnoreCase) < 0 && localizeDisplayText.IndexOf("VOICE", StringComparison.OrdinalIgnoreCase) < 0 && localeId.IndexOf("FOOTSTEP", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return null;
			}
			GameObject obj = Object.Instantiate<GameObject>(((Component)child).gameObject, parent);
			((Object)obj).name = "StayCombatFix_FootstepHeader";
			return obj;
		}

		private static void WireFootstepRow(FootstepRowUi rowUi, UnitEditorSelectableVoiceItem voiceItem)
		{
			//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_0062: Expected O, but got Unknown
			//IL_00f8: 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_0103: Expected O, but got Unknown
			ClearSubmitHandlers((UnitEditorSelectableItem)(object)voiceItem);
			((UnitEditorSelectableItem)voiceItem).Submitted += delegate
			{
				UnitEditorFootstepPicker.Open();
			};
			object? obj = CorrespondingButtonField?.GetValue(voiceItem);
			Button val = (Button)((obj is Button) ? obj : null);
			if (val != null)
			{
				object obj2 = <>O.<0>__Open;
				if (obj2 == null)
				{
					UnityAction val2 = UnitEditorFootstepPicker.Open;
					<>O.<0>__Open = val2;
					obj2 = (object)val2;
				}
				UnitEditorUiText.ReplaceButtonClick(val, (UnityAction)obj2);
			}
			if ((Object)(object)rowUi.PitchSlider != (Object)null)
			{
				rowUi.PitchSlider.minValue = 0.5f;
				rowUi.PitchSlider.maxValue = 1.5f;
				((UnityEventBase)rowUi.PitchSlider.onValueChanged).RemoveAllListeners();
				((UnityEvent<float>)(object)rowUi.PitchSlider.onValueChanged).AddListener((UnityAction<float>)delegate(float value)
				{
					_currentFootPitch = value;
					ApplyFootstepToEditorSpawnBlueprint(respawn: false);
				});
			}
			if ((Object)(object)rowUi.PreviewButton != (Object)null)
			{
				Button previewButton = rowUi.PreviewButton;
				object obj3 = <>O.<1>__PreviewCurrentFootstep;
				if (obj3 == null)
				{
					UnityAction val3 = PreviewCurrentFootstep;
					<>O.<1>__PreviewCurrentFootstep = val3;
					obj3 = (object)val3;
				}
				UnitEditorUiText.ReplaceButtonClick(previewButton, (UnityAction)obj3);
			}
		}

		private static void RefreshFootstepRowLabel()
		{
			if (!((Object)(object)_footstepRow == (Object)null))
			{
				FootstepDef byAudioRef = FootstepCatalog.GetByAudioRef(_currentFootRef);
				UnitEditorUiText.SetRawLocalizeText(_footstepRow.InlineHeaderText, "UNIT FOOTSTEP");
				UnitEditorUiText.SetRawLocalizeText(_footstepRow.SectionHeaderText, "UNIT FOOTSTEP");
				UnitEditorUiText.SetRawLocalizeText(_footstepRow.SelectionText, byAudioRef.DisplayName);
				if ((Object)(object)_footstepRow.SelectionIcon != (Object)null)
				{
					Sprite icon = FootstepIconResolver.GetIcon(byAudioRef);
					_footstepRow.SelectionIcon.sprite = icon;
					((Component)_footstepRow.SelectionIcon).gameObject.SetActive((Object)(object)icon != (Object)null);
				}
			}
		}

		internal static void RefreshFootstepRowUi()
		{
			if (!((Object)(object)_footstepRow == (Object)null) && !((Object)(object)((Component)_footstepRow).gameObject == (Object)null))
			{
				FootstepDef byAudioRef = FootstepCatalog.GetByAudioRef(_currentFootRef);
				UnitEditorFootstepDebug.Log("RefreshFootstepRowUi: footRef=" + _currentFootRef + " display=" + byAudioRef.DisplayName + " " + $"SectionHeader={(Object)(object)_footstepRow.SectionHeaderText != (Object)null} InlineHeader={(Object)(object)_footstepRow.InlineHeaderText != (Object)null} " + $"SelectionText={(Object)(object)_footstepRow.SelectionText != (Object)null} SelectionIcon={(Object)(object)_footstepRow.SelectionIcon != (Object)null} " + $"PitchSlider={(Object)(object)_footstepRow.PitchSlider != (Object)null}");
				RefreshFootstepRowLabel();
				if ((Object)(object)_footstepRow.PitchSlider != (Object)null)
				{
					_footstepRow.PitchSlider.value = _currentFootPitch;
				}
			}
		}

		private static void RefreshNavigation(UnitEditorBasePageUI basePage)
		{
			object? obj = ContentParentField?.GetValue(basePage);
			Transform val = (Transform)((obj is Transform) ? obj : null);
			if (val != null && !(GetSelectableChildrenMethod == null) && !(CreateExplicitLinearNavigationMethod == null))
			{
				Stopwatch stopwatch = null;
				object obj2 = GetSelectableChildrenMethod.Invoke(null, new object[2] { val, false });
				CreateExplicitLinearNavigationMethod.Invoke(null, new object[2] { obj2, false });
				if (stopwatch != null)
				{
					stopwatch.Stop();
					UnitEditorFootstepDebug.Log($"RefreshNavigation: {stopwatch.ElapsedMilliseconds}ms");
				}
			}
		}

		private static void ClearSubmitHandlers(UnitEditorSelectableItem item)
		{
			object? obj = SubmitEventField?.GetValue(item);
			UnityEvent val = (UnityEvent)((obj is UnityEvent) ? obj : null);
			if (val != null)
			{
				((UnityEventBase)val).RemoveAllListeners();
			}
		}

		private static bool IsFootstepRowSelected(UnitEditorBasePageUI basePage)
		{
			object? obj = AccessTools.Property(typeof(UnitEditorSubMenu), "SelectedItem")?.GetValue(basePage, null);
			UnitEditorSelectableItem val = (UnitEditorSelectableItem)((obj is UnitEditorSelectableItem) ? obj : null);
			if (val == null)
			{
				return false;
			}
			return (Object)(object)((Component)val).GetComponent<FootstepRowMarker>() != (Object)null;
		}

		private static void AdjustFootstepPitch(float delta)
		{
			if (!((Object)(object)_footstepRow?.PitchSlider == (Object)null))
			{
				_footstepRow.PitchSlider.value = Mathf.Clamp(_footstepRow.PitchSlider.value + delta, 0.5f, 1.5f);
			}
		}

		private static bool TryGetEditorSpawnBlueprint(out UnitEditorManager manager, out UnitBlueprint blueprint)
		{
			manager = Object.FindObjectOfType<UnitEditorManager>();
			blueprint = null;
			if ((Object)(object)manager == (Object)null)
			{
				return false;
			}
			if (!(EditorUnitBasesField?.GetValue(manager) is UnitBaseWrapper[] array) || !(EditorCurrentUnitBaseField?.GetValue(manager) is int num) || num < 0 || num >= array.Length)
			{
				return false;
			}
			blueprint = array[num].UnitBaseBlueprint;
			return (Object)(object)blueprint != (Object)null;
		}

		private static void StripFootstepMetadataFromDescriptionField()
		{
			if (!TryGetEditorSpawnBlueprint(out var manager, out var _))
			{
				return;
			}
			UnitEditorUIManager uIManager = manager.UIManager;
			if (!((Object)(object)uIManager == (Object)null) && !(GetUnitDescriptionMethod == null) && !(SetUnitDescriptionMethod == null))
			{
				string obj = (GetUnitDescriptionMethod.Invoke(uIManager, null) as string) ?? string.Empty;
				string text = FootstepMetadata.Strip(obj);
				if (!string.Equals(obj, text, StringComparison.Ordinal))
				{
					SetUnitDescriptionMethod.Invoke(uIManager, new object[1] { text });
				}
				object? obj2 = EditorLoadedUnitField?.GetValue(manager);
				UnitBlueprint val = (UnitBlueprint)((obj2 is UnitBlueprint) ? obj2 : null);
				if (val != null && (Object)(object)val != (Object)null)
				{
					val.UnitDescription = FootstepMetadata.Strip(val.UnitDescription);
				}
			}
		}

		private static void SyncLiveUnitFootSounds(UnitEditorManager manager, UnitBlueprint blueprint)
		{
			if (!(EditorSpawnedBaseField?.GetValue(manager) is GameObject[] array) || array == null || array.Length == 0 || (Object)(object)array[0] == (Object)null)
			{
				return;
			}
			AudioPathData val = FootstepBlueprintHelper.BuildFootPathData(FootstepBlueprintHelper.GetFootRef(blueprint), FootstepBlueprintHelper.GetFootPitch(blueprint));
			if (val != null)
			{
				UnitSounds componentInChildren = array[0].GetComponentInChildren<UnitSounds>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.FootPathData = val;
				}
			}
		}
	}
	internal static class UnitEditorCustomTargeting
	{
		internal sealed class CustomTargetingDef
		{
			internal readonly string DisplayName;

			internal readonly Type ComponentType;

			internal readonly ITargetingComponent Component;

			internal CustomTargetingDef(string displayName, Type componentType, ITargetingComponent component)
			{
				DisplayName = displayName;
				ComponentType = componentType;
				Component = component;
			}
		}

		private static readonly CustomTargetingDef[] Definitions = new CustomTargetingDef[3]
		{
			new CustomTargetingDef("MOST EXPENSIVE ENEMY", typeof(EnemyHighestPriceTargeting), (ITargetingComponent)(object)default(EnemyHighestPriceTargeting)),
			new CustomTargetingDef("LOWEST HEALTH ENEMY", typeof(EnemyLowestHealthTargeting), (ITargetingComponent)(object)default(EnemyLowestHealthTargeting)),
			new CustomTargetingDef("RANGED ENEMIES", typeof(EnemyRangedMixedTargeting), (ITargetingComponent)(object)default(EnemyRangedMixedTargeting))
		};

		internal static void EnsureTargetingInjected(UnitEditorManager manager)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if (!UnitEditorConfig.CustomTargetingTypesEnabled || (Object)(object)manager == (Object)null)
			{
				return;
			}
			if (manager.TargetingTypesComponents == null)
			{
				manager.TargetingTypesComponents = new List<ITargetingComponent>();
			}
			List<ITargetingComponent> list = new List<ITargetingComponent>(manager.TargetingTypesComponents);
			List<TargetingTypeWrapper> list2 = BuildTypeWrappers(manager.TargetingTypes, list.Count);
			RemoveCustomEntries(list, list2);
			int num = FindEnemyInsertIndex(list);
			CustomTargetingDef[] definitions = Definitions;
			foreach (CustomTargetingDef customTargetingDef in definitions)
			{
				if (!HasTargetingType(list, customTargetingDef.ComponentType))
				{
					list.Insert(num, customTargetingDef.Component);
					list2.Insert(num, new TargetingTypeWrapper
					{
						DisplayName = customTargetingDef.DisplayName
					});
					num++;
				}
			}
			manager.TargetingTypesComponents = list;
			manager.TargetingTypes = list2.ToArray();
		}

		private static List<TargetingTypeWrapper> BuildTypeWrappers(TargetingTypeWrapper[] existing, int componentCount)
		{
			//IL_0016: 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)
			List<TargetingTypeWrapper> list = ((existing != null) ? new List<TargetingTypeWrapper>(existing) : new List<TargetingTypeWrapper>());
			while (list.Count < componentCount)
			{
				list.Add(default(TargetingTypeWrapper));
			}
			if (list.Count > componentCount)
			{
				list.RemoveRange(componentCount, list.Count - componentCount);
			}
			return list;
		}

		private static void RemoveCustomEntries(List<ITargetingComponent> components, List<TargetingTypeWrapper> types)
		{
			for (int num = components.Count - 1; num >= 0; num--)
			{
				if (IsCustomType(((object)components[num])?.GetType()))
				{
					components.RemoveAt(num);
					if (num < types.Count)
					{
						types.RemoveAt(num);
					}
				}
			}
		}

		private static int FindEnemyInsertIndex(IReadOnlyList<ITargetingComponent> components)
		{
			int num = -1;
			for (int i = 0; i < components.Count; i++)
			{
				if (IsVanillaEnemyTargetingType(((object)components[i])?.GetType()))
				{
					num = i;
				}
			}
			return num + 1;
		}

		private static bool IsVanillaEnemyTargetingType(Type componentType)
		{
			if (componentType != null && componentType.Name.StartsWith("Enemy", StringComparison.Ordinal))
			{
				return !IsCustomType(componentType);
			}
			return false;
		}

		private static bool IsCustomType(Type componentType)
		{
			if (componentType == null)
			{
				return false;
			}
			for (int i = 0; i < Definitions.Length; i++)
			{
				if (Definitions[i].ComponentType == componentType)
				{
					return true;
				}
			}
			return false;
		}

		private static bool HasTargetingType(List<ITargetingComponent> components, Type componentType)
		{
			for (int i = 0; i < components.Count; i++)
			{
				if (((object)components[i])?.GetType() == componentType)
				{
					return true;
				}
			}
			return false;
		}

		public static void Awake_Prefix(UnitEditorManager __instance)
		{
			EnsureTargetingInjected(__instance);
		}

		public static void UIManager_Start_Prefix(UnitEditorUIManager __instance)
		{
			if (UnitEditorConfig.CustomTargetingTypesEnabled)
			{
				UnitEditorManager val = Object.FindObjectOfType<UnitEditorManager>();
				if ((Object)(object)val != (Object)null)
				{
					EnsureTargetingInjected(val);
				}
			}
		}

		public static void LoadUnit_Prefix(UnitEditorManager __instance)
		{
			EnsureTargetingInjected(__instance);
		}

		public static void GetTargetIndex_Postfix(ITargetingComponent component, ref int __result)
		{
			if (!UnitEditorConfig.CustomTargetingTypesEnabled || component == null || __result != 0)
			{
				return;
			}
			for (int i = 0; i < Definitions.Length; i++)
			{
				if (!(Definitions[i].ComponentType != ((object)component).GetType()))
				{
					__result = FindIndexForType(((object)component).GetType());
					break;
				}
			}
		}

		private static int FindIndexForType(Type componentType)
		{
			UnitEditorManager val = Object.FindObjectOfType<UnitEditorManager>();
			if (val?.TargetingTypesComponents == null)
			{
				return 0;
			}
			for (int i = 0; i < val.TargetingTypesComponents.Count; i++)
			{
				if (((object)val.TargetingTypesComponents[i])?.GetType() == componentType)
				{
					return i;
				}
			}
			return 0;
		}
	}
	internal static class UnitEditorCustomVoiceButton
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__Open;
		}

		internal const string ButtonName = "TabsUnlimited_CustomVoiceButton";

		private const string FootstepRowName = "StayCombatFix_FootstepRow";

		private static readonly FieldInfo VoiceSelectField = AccessTools.Field(typeof(UnitEditorBasePageUI), "voiceSelect");

		private static readonly FieldInfo ContentParentField = AccessTools.Field(typeof(UnitEditorBasePageUI), "contentParent");

		public static void BasePage_Open_Postfix(UnitEditorBasePageUI __instance)
		{
			if (UnitEditorConfig.CustomVoicesEnabled)
			{
				EnsureButton(__instance);
			}
		}

		internal static void StripFromTransform(Transform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name == "TabsUnlimited_CustomVoiceButton")
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
		}

		private static void EnsureButton(UnitEditorBasePageUI basePage)
		{
			object? obj = VoiceSelectField?.GetValue(basePage);
			UnitEditorSelectableVoiceItem val = (UnitEditorSelectableVoiceItem)((obj is UnitEditorSelectableVoiceItem) ? obj : null);
			if (val == null)
			{
				return;
			}
			StripFromFootstepRows(basePage);
			RemoveStaleButtonsFromVoiceRow(((Component)val).transform);
			Transform val2 = FindNameRow(((Component)val).transform);
			if ((Object)(object)val2 == (Object)null)
			{
				Plugin.LogWarning("Custom voice button: UnitVoiceName row not found");
				return;
			}
			Transform val3 = FindExistingButton(val2);
			if (val3 != null)
			{
				UpdateButtonAppearance(val3);
				return;
			}
			UpdateButtonAppearance(CreateButtonObject(val2).transform);
			UnitEditorBasePageScroll.ScheduleSetup(basePage);
		}

		private static GameObject CreateButtonObject(Transform nameRow)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_005f: 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_00be: 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_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_00e5: 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_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_008a: Expected O, but got Unknown
			GameObject val = new GameObject("TabsUnlimited_CustomVoiceButton", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(nameRow, false);
			((Graphic)val.GetComponent<Image>()).color = new Color(0.08f, 0.08f, 0.08f, 0.95f);
			Button component = val.GetComponent<Button>();
			object obj = <>O.<0>__Open;
			if (obj == null)
			{
				UnityAction val2 = CustomVoiceEditorOverlay.Open;
				<>O.<0>__Open = val2;
				obj = (object)val2;
			}
			UnitEditorUiText.ReplaceButtonClick(component, (UnityAction)obj);
			GameObject val3 = new GameObject("Label", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(val.transform, false);
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			Text obj2 = val3.AddComponent<Text>();
			obj2.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			obj2.fontSize = 18;
			obj2.alignment = (TextAnchor)4;
			((Graphic)obj2).color = Color.white;
			obj2.text = "Add/Edit Voices";
			return val;
		}

		private static void UpdateButtonAppearance(Transform buttonTransform)
		{
			//IL_0011: 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_003b: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)buttonTransform).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(1f, 0.5f);
			component.anchorMax = new Vector2(1f, 0.5f);
			component.pivot = new Vector2(1f, 0.5f);
			component.anchoredPosition = new Vector2(-8f, 0f);
			component.sizeDelta = new Vector2(236f, 52f);
			Text componentInChildren = ((Component)buttonTransform).GetComponentInChildren<Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.fontSize = 18;
				componentInChildren.text = "Add/Edit Voices";
			}
		}

		private static void StripFromFootstepRows(UnitEditorBasePageUI basePage)
		{
			object? obj = ContentParentField?.GetValue(basePage);
			Transform val = (Transform)((obj is Transform) ? obj : null);
			if (val == null)
			{
				return;
			}
			Transform[] componentsInChildren = ((Component)val).GetComponentsInChildren<Transform>(true);
			foreach (Transform val2 in componentsInChildren)
			{
				if (!(((Object)val2).name != "StayCombatFix_FootstepRow"))
				{
					StripFromTransform(val2);
				}
			}
		}

		private static void RemoveStaleButtonsFromVoiceRow(Transform voiceRoot)
		{
			List<Transform> list = new List<Transform>();
			Transform[] componentsInChildren = ((Component)voiceRoot).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name == "TabsUnlimited_CustomVoiceButton")
				{
					list.Add(val);
				}
			}
			Transform val2 = FindNameRow(voiceRoot);
			for (int j = 0; j < list.Count; j++)
			{
				if (!((Object)(object)val2 != (Object)null) || !list[j].IsChildOf(val2))
				{
					Object.Destroy((Object)(object)((Component)list[j]).gameObject);
				}
			}
		}

		private static Transform FindNameRow(Transform voiceRoot)
		{
			Transform[] componentsInChildren = ((Component)voiceRoot).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name.IndexOf("UnitVoiceName", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return val;
				}
			}
			return null;
		}

		private static Transform FindExistingButton(Transform root)
		{
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name == "TabsUnlimited_CustomVoiceButton")
				{
					return val;
				}
			}
			return null;
		}
	}
	internal static class UnitEditorFleeDistance
	{
		private sealed class FleeDistanceInputActivator : MonoBehaviour, IPointerClickHandler, IEventSystemHandler
		{
			private InputField _field;

			public void Init(InputField field)
			{
				_field = field;
			}

			public void OnPointerClick(PointerEventData eventData)
			{
				if (!((Object)(object)_field == (Object)null))
				{
					((Selectable)_field).Select();
					_field.ActivateInputField();
					((AbstractEventData)eventData).Use();
				}
			}
		}

		[CompilerGenerated]
		private sealed class <DeferredLayoutRefresh>d__61 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public UnitEditorBasePageUI basePage;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DeferredLayoutRefresh>d__61(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (RefreshLayoutNow(basePage))
					{
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					break;
				case 3:
					<>1__state = -1;
					RefreshLayoutNow(basePage);
					break;
				}
				_layoutCoroutine = null;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		internal const string PanelName = "TabsUnlimited_FleeDistancePanel";

		private const string DisplayName = "FLEE DISTANCE";

		private const float DistanceStep = 0.5f;

		private const float IconGutterGap = 8f;

		private const float IconGutterAnchorXFallback = 134f;

		private const float IconVerticalOffset = 10f;

		private const float IconFallbackVerticalOffset = 22f;

		private const float IconFrameMinSize = 40f;

		private const float IconFrameMaxSize = 80f;

		private static readonly Vector2 PanelSize = new Vector2(54f, 32f);

		private static readonly Vector2 InputSize = new Vector2(36f, 30f);

		private static readonly Vector2 SuffixSize = new Vector2(16f, 30f);

		private static readonly FieldInfo MovementTypeField = AccessTools.Field(typeof(UnitEditorBasePageUI), "movementType");

		private static readonly FieldInfo EditorUnitBasesField = AccessTools.Field(typeof(UnitEditorManager), "UnitBases");

		private static readonly FieldInfo EditorCurrentUnitBaseField = AccessTools.Field(typeof(UnitEditorManager), "currentUnitBase");

		private static readonly FieldInfo EditorLoadedUnitField = AccessTools.Field(typeof(UnitEditorManager), "loadedUnit");

		private static readonly FieldInfo MovementTypesComponentsField = AccessTools.Field(typeof(UnitEditorManager), "MovementTypesComponents");

		private static readonly FieldInfo CurrentMovementTypeField = AccessTools.Field(typeof(UnitEditorManager), "currentMovementType");

		private static readonly MethodInfo GetUnitDescriptionMethod = AccessTools.Method(typeof(UnitEditorUIManager), "GetUnitDescrption", (Type[])null, (Type[])null);

		private static readonly MethodInfo SetUnitDescriptionMethod = AccessTools.Method(typeof(UnitEditorUIManager), "SetDescription", (Type[])null, (Type[])null);

		private static GameObject _panel;

		private static InputField _inputField;

		private static Coroutine _layoutCoroutine;

		private static bool _updatingUi;

		private static bool _loggedPlacement;

		private static string _lastPlacementStrategy = "none";

		private static RectTransform _lastResolvedIconRect;

		private static float _fleeDistance = 5f;

		public static void Awake_Prefix(UnitEditorManager __instance)
		{
			EnsureFleeDistanceInjected(__instance);
		}

		public static void UIManager_Start_Prefix(UnitEditorUIManager __instance)
		{
			if (UnitEditorConfig.FleeDistanceEnabled)
			{
				UnitEditorManager val = Object.FindObjectOfType<UnitEditorManager>();
				if ((Object)(object)val != (Object)null)
				{
					EnsureFleeDistanceInjected(val);
				}
			}
		}

		public static void BasePage_Open_Postfix(UnitEditorBasePageUI __instance)
		{
			if (!UnitEditorConfig.FleeDistanceEnabled)
			{
				CleanupPanel();
				return;
			}
			_loggedPlacement = false;
			EnsurePanel(__instance);
			UnitEditorManager val = Object.FindObjectOfType<UnitEditorManager>();
			if ((Object)(object)val != (Object)null && IsCurrentMovementFlee(val))
			{
				TryApplyFromActiveBlueprint(val);
			}
			RefreshPanelVisibility();
			RefreshPanelUi();
			ScheduleDeferredLayoutRefresh(__instance);
		}

		public static void BasePage_Close_Postfix(UnitEditorBasePageUI __instance)
		{
			StopLayoutCoroutine();
			UnitEditorBasePageScroll.Cleanup(__instance);
		}

		public static void LoadUnit_Postfix(UnitEditorManager __instance, UnitBlueprint blueprint)
		{
			if (UnitEditorConfig.FleeDistanceEnabled && !((Object)(object)blueprint == (Object)null))
			{
				EnsureFleeDistanceInjected(__instance);
				ApplyFromBlueprint(blueprint);
				StripMetadataFromDescriptionField(__instance);
				RefreshPanelVisibility();
				RefreshPanelUi();
			}
		}

		public static void ClearUnit_Postfix()
		{
			if (UnitEditorConfig.FleeDistanceEnabled)
			{
				_fleeDistance = 5f;
				RefreshPanelVisibility();
				RefreshPanelUi();
			}
		}

		public static void GetBlueprint_Prefix(UnitEditorManager __instance)
		{
			//IL_0043: 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)
			if (UnitEditorConfig.FleeDistanceEnabled && !((Object)(object)__instance == (Object)null) && IsCurrentMovementFlee(__instance))
			{
				int num = FindFleeDistanceIndex();
				if (num >= 0 && __instance.MovementTypesComponents != null && num < __instance.MovementTypesComponents.Count)
				{
					__instance.MovementTypesComponents[num] = (IMovementComponent)(object)new FleeDistance
					{
						Value = _fleeDistance
					};
				}
			}
		}

		public static void GetBlueprint_Postfix(UnitEditorManager __instance, ref UnitBlueprint __result)
		{
			if (UnitEditorConfig.FleeDistanceEnabled && !((Object)(object)__result == (Object)null) && IsCurrentMovementFlee(__instance))
			{
				FleeDistanceHelper.EnsureFleeDistanceComponent(__result, _fleeDistance);
			}
		}

		public static void SelectMovementType_Postfix(UnitEditorManager __instance)
		{
			if (!UnitEditorConfig.FleeDistanceEnabled || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			if (IsCurrentMovementFlee(__instance))
			{
				TryApplyFromActiveBlueprint(__instance);
			}
			SyncLiveBlueprint(__instance);
			UnitEditorBasePageUI val = Object.FindObjectOfType<UnitEditorBasePageUI>();
			if (!((Object)(object)val == (Object)null))
			{
				if (IsCurrentMovementFlee(__instance))
				{
					EnsurePanel(val);
				}
				RefreshPanelVisibility();
				RefreshPanelUi();
				ScheduleDeferredLayoutRefresh(val);
			}
		}

		public static void RespawnUnit_Postfix(UnitEditorManager __instance)
		{
			if (UnitEditorConfig.FleeDistanceEnabled && !((Object)(object)__instance == (Object)null))
			{
				SyncLiveBlueprint(__instance);
			}
		}

		public static void SerializedUnit_Postfix(UnitBlueprint __instance, ref SerializedUnitBlueprint __result)
		{
			if (UnitEditorConfig.FleeDistanceEnabled && !((Object)(object)__instance == (Object)null) && __result != null && FleeDistanceHelper.HasFleeDistanceMovement(__instance.MovementComponents))
			{
				float fleeDistance = FleeDistanceHelper.GetFleeDistance(__instance);
				__result.unitDescription = FleeDistanceMetadata.EmbedForSave(__result.unitDescription, fleeDistance);
			}
		}

		public static void DeserializedUnit_Postfix(SerializedUnitBlueprint data, ref UnitBlueprint __result)
		{
			if (UnitEditorConfig.FleeDistanceEnabled && data != null && !((Object)(object)__result == (Object)null))
			{
				if (FleeDistanceMetadata.TryParse(data.unitDescription, out var fleeDistanceMeters, out var cleanDescription))
				{
					FleeDistanceHelper.SetFleeDistance(__result, fleeDistanceMeters);
					__result.UnitDescription = cleanDescription;
				}
				else
				{
					FleeDistanceHelper.RestoreFleeDistanceValue(__result);
				}
			}
		}

		public static void GetMovementIndex_Postfix(IMovementComponent component, ref int __result)
		{
			if (UnitEditorConfig.FleeDistanceEnabled && component != null && __result == 0 && component is FleeDistance)
			{
				int num = FindFleeDistanceIndex();
				if (num >= 0)
				{
					__result = num;
				}
			}
		}

		public static bool PerformIncreaseAction_Prefix(UnitEditorBasePageUI __instance)
		{
			if (!UnitEditorConfig.FleeDistanceEnabled || !IsMovementRowSelected(__instance) || !IsPanelVisible())
			{
				return true;
			}
			AdjustFleeDistance(0.5f);
			return false;
		}

		public static bool PerformDecreaseAction_Prefix(UnitEditorBasePageUI __instance)
		{
			if (!UnitEditorConfig.FleeDistanceEnabled || !IsMovementRowSelected(__instance) || !IsPanelVisible())
			{
				return true;
			}
			AdjustFleeDistance(-0.5f);
			return false;
		}

		internal static void EnsureFleeDistanceInjected(UnitEditorManager manager)
		{
			//IL_0061: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if (UnitEditorConfig.FleeDistanceEnabled && !((Object)(object)manager == (Object)null))
			{
				if (manager.MovementTypesComponents == null)
				{
					manager.MovementTypesComponents = new List<IMovementComponent>();
				}
				List<IMovementComponent> list = new List<IMovementComponent>(manager.MovementTypesComponents);
				List<MovementTypeWrapper> list2 = BuildMovementTypeWrappers(manager.MovementTypes, list.Count);
				if (HasFleeDistanceType(list))
				{
					manager.MovementTypesComponents = list;
					manager.MovementTypes = list2.ToArray();
					return;
				}
				list.Add((IMovementComponent)(object)new FleeDistance
				{
					Value = 5f
				});
				list2.Add(new MovementTypeWrapper
				{
					DisplayName = "FLEE DISTANCE"
				});
				manager.MovementTypesComponents = list;
				manager.MovementTypes = list2.ToArray();
			}
		}

		private static void ApplyFromBlueprint(UnitBlueprint blueprint)
		{
			if (!((Object)(object)blueprint == (Object)null))
			{
				string arg = ResolveFleeDistanceSource(blueprint);
				FleeDistanceHelper.RestoreFleeDistanceValue(blueprint);
				_fleeDistance = FleeDistanceHelper.GetFleeDistance(blueprint);
				if (!Mathf.Approximately(_fleeDistance, 5f))
				{
					Plugin.LogInfo($"Flee distance UI loaded: {_fleeDistance} (source={arg})");
				}
			}
		}

		private static string ResolveFleeDistanceSource(UnitBlueprint blueprint)
		{
			if (FleeDistanceMetadata.TryParse(blueprint.UnitDescription, out var fleeDistanceMeters, out var _))
			{
				return "metadata";
			}
			if (FleeDistanceHelper.TryGetCachedDistance(blueprint, out fleeDistanceMeters))
			{
				return "cache";
			}
			float num = FleeDistanceHelper.ReadComponentFleeDistance(blueprint);
			if (num > 0f && !Mathf.Approximately(num, 5f))
			{
				return "component";
			}
			return "default";
		}

		private static void TryApplyFromActiveBlueprint(UnitEditorManager manager)
		{
			if (TryGetActiveEditorBlueprint(manager, out var blueprint))
			{
				ApplyFromBlueprint(blueprint);
			}
		}

		private static bool TryGetActiveEditorBlueprint(UnitEditorManager manager, out UnitBlueprint blueprint)
		{
			blueprint = null;
			if ((Object)(object)manager == (Object)null)
			{
				return false;
			}
			object? obj = EditorLoadedUnitField?.GetValue(manager);
			UnitBlueprint val = (UnitBlueprint)((obj is UnitBlueprint) ? obj : null);
			if (val != null && (Object)(object)val != (Object)null)
			{
				blueprint = val;
				return true;
			}
			return TryGetEditorSpawnBlueprint(manager, out blueprint);
		}

		private static void EnsurePanel(UnitEditorBasePageUI basePage)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_00b3: 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_00ee: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			object? obj = MovementTypeField?.GetValue(basePage);
			UnitEditorSelectableItem val = (UnitEditorSelectableItem)((obj is UnitEditorSelectableItem) ? obj : null);
			if (val != null)
			{
				Transform transform = ((Component)val).transform;
				if ((Object)(object)_panel != (Object)null && (Object)(object)_panel.transform.parent == (Object)(object)transform)
				{
					RefreshPanelLayout(basePage, transform);
					return;
				}
				CleanupPanel();
				_panel = new GameObject("TabsUnlimited_FleeDistancePanel", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				_panel.transform.SetParent(transform, false);
				Image component = _panel.GetComponent<Image>();
				((Graphic)component).color = new Color(0.08f, 0.08f, 0.08f, 0.95f);
				((Graphic)component).raycastTarget = true;
				GameObject val2 = new GameObject("Input", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val2.transform.SetParent(_panel.transform, false);
				AnchorLeftCenter(val2.GetComponent<RectTransform>(), Vector2.zero, InputSize);
				Image component2 = val2.GetComponent<Image>();
				((Graphic)component2).color = new Color(0.14f, 0.14f, 0.16f, 1f);
				((Graphic)component2).raycastTarget = true;
				GameObject val3 = new GameObject("Text", new Type[1] { typeof(RectTransform) });
				val3.transform.SetParent(val2.transform, false);
				StretchFull(val3.GetComponent<RectTransform>(), 4f, 2f, -4f, -2f);
				Text val4 = val3.AddComponent<Text>();
				val4.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
				val4.fontSize = 15;
				val4.alignment = (TextAnchor)4;
				((Graphic)val4).color = Color.white;
				val4.supportRichText = false;
				((Graphic)val4).raycastTarget = false;
				_inputField = val2.AddComponent<InputField>();
				_inputField.textComponent = val4;
				((Selectable)_inputField).targetGraphic = (Graphic)(object)component2;
				_inputField.contentType = (ContentType)3;
				_inputField.placeholder = CreateInputPlaceholder(val2.transform, 5f.ToString("0.#", CultureInfo.InvariantCulture));
				((UnityEvent<string>)(object)_inputField.onEndEdit).AddListener((UnityAction<string>)OnInputEndEdit);
				_inputField.text = FormatDistance(_fleeDistance);
				val2.AddComponent<FleeDistanceInputActivator>().Init(_inputField);
				GameObject val5 = new GameObject("Suffix", new Type[1] { typeof(RectTransform) });
				val5.transform.SetParent(_panel.transform, false);
				AnchorLeftCenter(val5.GetComponent<RectTransform>(), new Vector2(InputSize.x, 0f), SuffixSize);
				Text obj2 = val5.AddComponent<Text>();
				obj2.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
				obj2.fontSize = 14;
				obj2.alignment = (TextAnchor)3;
				((Graphic)obj2).color = new Color(0.85f, 0.85f, 0.85f, 1f);
				obj2.text = "D";
				((Graphic)obj2).raycastTarget = false;
				_panel.AddComponent<LayoutElement>().ignoreLayout = true;
				RefreshPanelLayout(basePage, transform);
				UnitEditorBasePageScroll.ScheduleSetup(basePage);
				ScheduleDeferredLayoutRefresh(basePage);
			}
		}

		private static void RefreshPanelLayout(UnitEditorBasePageUI basePage, Transform movementRoot)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_panel == (Object)null || (Object)(object)movementRoot == (Object)null || (Object)(object)basePage == (Object)null)
			{
				return;
			}
			RectTransform val = (RectTransform)(object)((movementRoot is RectTransform) ? movementRoot : null);
			if (val != null)
			{
				if ((Object)(object)_panel.transform.parent != (Object)(object)movementRoot)
				{
					_panel.transform.SetParent(movementRoot, false);
				}
				RectTransform component = _panel.GetComponent<RectTransform>();
				component.sizeDelta = PanelSize;
				RectTransform val2 = (_lastResolvedIconRect = ResolveMovementIconRect(basePage, movementRoot, out _lastPlacementStrategy));
				if ((Object)(object)val2 != (Object)null)
				{
					PlacePanelLeftOfIcon(component, val, val2, 8f);
				}
				else
				{
					PlacePanelFallback(component, val, movementRoot);
				}
				_panel.transform.SetAsLastSibling();
			}
		}

		private static RectTransform ResolveMovementIconRect(UnitEditorBasePageUI basePage, Transform movementRoot, out string strategy)
		{
			strategy = "fallback";
			RectTransform val = UnitEditorMoveWhileTurning.TryMirrorVoiceIconRect(basePage, movementRoot);
			if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeInHierarchy && !IsUnderCheatBranch((Transform)(object)val, movementRoot))
			{
				strategy = "mirrored";
				return NormalizeIconContainer(val);
			}
			RectTransform searchRoot = UnitEditorMoveWhileTurning.TryGetMovementValueRowRect(movementRoot);
			RectTransform val2 = FindVisibleNamedIconRect((Transform)(object)searchRoot, movementRoot) ?? FindVisibleNamedIconRect(movementRoot, movementRoot);
			if ((Object)(object)val2 != (Object)null)
			{
				strategy = "named";
				return NormalizeIconContainer(val2);
			}
			RectTransform val3 = FindVisibleSpriteIconRect((Transform)(object)searchRoot, movementRoot) ?? FindVisibleSpriteIconRect(movementRoot, movementRoot);
			if ((Object)(object)val3 != (Object)null)
			{
				strategy = "sprite";
				return NormalizeIconContainer(val3);
			}
			return null;
		}

		private static void PlacePanelLeftOfIcon(RectTransform panelRect, RectTransform movementRect, RectTransform iconRect, float gap)
		{
			//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)
			//IL_005c: 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_007d: 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_009d: 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)
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			iconRect.GetWorldCorners(array);
			float x = array[0].x;
			float num = (array[0].y + array[1].y) * 0.5f + 10f;
			Vector3 val = ((Transform)movementRect).InverseTransformPoint(new Vector3(x - gap, num, array[0].z));
			panelRect.pivot = new Vector2(1f, 0.5f);
			panelRect.anchorMin = new Vector2(0.5f, 0.5f);
			panelRect.anchorMax = new Vector2(0.5f, 0.5f);
			panelRect.anchoredPosition = Vector2.op_Implicit(val);
		}

		private static void PlacePanelFallback(RectTransform panelRect, RectTransform movementRect, Transform movementRoot)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0031: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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_0060: 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_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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			float num = 22f;
			RectTransform val = UnitEditorMoveWhileTurning.TryGetTurningButtonRect(movementRoot);
			Rect rect;
			if ((Object)(object)val != (Object)null)
			{
				rect = val.rect;
				Vector3 val2 = ((Transform)val).TransformPoint(Vector2.op_Implicit(((Rect)(ref rect)).center));
				num = ((Transform)movementRect).InverseTransformPoint(val2).y + 22f;
			}
			else
			{
				RectTransform val3 = UnitEditorMoveWhileTurning.TryGetMovementValueRowRect(movementRoot);
				if ((Object)(object)val3 != (Object)null)
				{
					rect = val3.rect;
					Vector3 val4 = ((Transform)val3).TransformPoint(Vector2.op_Implicit(((Rect)(ref rect)).center));
					num = ((Transform)movementRect).InverseTransformPoint(val4).y + 22f;
				}
			}
			panelRect.pivot = new Vector2(1f, 0.5f);
			panelRect.anchorMin = new Vector2(0f, 0.5f);
			panelRect.anchorMax = new Vector2(0f, 0.5f);
			panelRect.anchoredPosition = new Vector2(134f, num);
		}

		private static RectTransform FindVisibleNamedIconRect(Transform searchRoot, Transform movementRoot)
		{
			if ((Object)(object)searchRoot == (Object)null)
			{
				return null;
			}
			Transform[] componentsInChildren = ((Component)searchRoot).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name.IndexOf("UnitVoiceIcon", StringComparison.OrdinalIgnoreCase) >= 0 && !IsUnderCheatBranch(val, movementRoot) && ((Component)val).gameObject.activeInHierarchy)
				{
					RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
					if (val2 != null)
					{
						return val2;
					}
				}
			}
			return null;
		}

		private static RectTransform FindVisibleSpriteIconRect(Transform searchRoot, Transform movementRoot)
		{
			//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)
			if ((Object)(object)searchRoot == (Object)null)
			{
				return null;
			}
			Image val = null;
			float num = float.MaxValue;
			float num2 = float.MaxValue;
			Image[] componentsInChildren = ((Component)searchRoot).GetComponentsInChildren<Image>(true);
			foreach (Image val2 in componentsInChildren)
			{
				Image val3 = ResolveMovementRowIconImage(val2);
				if ((Object)(object)val3 == (Object)null || (Object)(object)val3.sprite == (Object)null || !((Component)val2).gameObject.activeInHierarchy || IsUnderCheatBranch(((Component)val2).transform, movementRoot) || IsExcludedMovementIconImage(val3))
				{
					continue;
				}
				Rect rect = ((Graphic)val3).rectTransform.rect;
				float num3 = ((Rect)(ref rect)).width * ((Rect)(ref rect)).height;
				if (!(num3 <= 0f))
				{
					Vector3[] array = (Vector3[])(object)new Vector3[4];
					((Graphic)val3).rectTransform.GetWorldCorners(array);
					float x = array[0].x;
					if (num3 < num || (Mathf.Approximately(num3, num) && x < num2))
					{
						val = val3;
						num = num3;
						num2 = x;
					}
				}
			}
			if (val == null)
			{
				return null;
			}
			return ((Graphic)val).rectTransform;
		}

		private static Image ResolveMovementRowIconImage(Image image)
		{
			if ((Object)(object)image == (Object)null)
			{
				return null;
			}
			if ((Object)(object)image.sprite != (Object)null)
			{
				return image;
			}
			Image[] componentsInChildren = ((Component)image).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val.sprite != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static RectTransform NormalizeIconContainer(RectTransform iconRect)
		{
			//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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)iconRect == (Object)null)
			{
				return null;
			}
			RectTransform val = iconRect;
			while ((Object)(object)val != (Object)null)
			{
				Rect rect = val.rect;
				float num = Mathf.Abs(((Rect)(ref rect)).width);
				rect = val.rect;
				float num2 = Mathf.Max(num, Mathf.Abs(((Rect)(ref rect)).height));
				if (num2 >= 40f && num2 <= 80f)
				{
					return val;
				}
				Transform parent = ((Transform)val).parent;
				RectTransform val2 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				if (val2 == null)
				{
					break;
				}
				val = val2;
			}
			return iconRect;
		}

		private static bool IsExcludedMovementIconImage(Image image)
		{
			Transform val = ((Component)image).transform;
			while ((Object)(object)val != (Object)null)
			{
				string name = ((Object)val).name;
				if (name.StartsWith("TabsUnlimited_", StringComparison.Ordinal))
				{
					return true;
				}
				if (name == "TabsUnlimited_MoveWhileTurningButton")
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		private static bool IsUnderCheatBranch(Transform transform, Transform movementRoot)
		{
			Transform val = transform;
			while ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)movementRoot)
			{
				if (((Object)val).name.IndexOf("Cheat", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		private static void AnchorLeftCenter(RectTransform rect, Vector2 anchoredPosition, Vector2 sizeDelta)
		{
			//IL_000b: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(0f, 0.5f);
			rect.anchorMax = new Vector2(0f, 0.5f);
			rect.pivot = new Vector2(0f, 0.5f);
			rect.anchoredPosition = anchoredPosition;
			rect.sizeDelta = sizeDelta;
		}

		private static void ScheduleDeferredLayoutRefresh(UnitEditorBasePageUI basePage)
		{
			if (!((Object)(object)basePage == (Object)null) && !((Object)(object)Plugin.Instance == (Object)null))
			{
				StopLayoutCoroutine();
				_layoutCoroutine = ((MonoBehaviour)Plugin.Instance).StartCoroutine(DeferredLayoutRefresh(basePage));
			}
		}

		[IteratorStateMachine(typeof(<DeferredLayoutRefresh>d__61))]
		private static IEnumerator DeferredLayoutRefresh(UnitEditorBasePageUI basePage)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DeferredLayoutRefresh>d__61(0)
			{
				basePage = basePage
			};
		}

		private static bool RefreshLayoutNow(UnitEditorBasePageUI basePage)
		{
			if (!UnitEditorConfig.FleeDistanceEnabled || (Object)(object)basePage == (Object)null)
			{
				return false;
			}
			object? obj = MovementTypeField?.GetValue(basePage);
			UnitEditorSelectableItem val = (UnitEditorSelectableItem)((obj is UnitEditorSelectableItem) ? obj : null);
			if (val == null)
			{
				return false;
			}
			Transform transform = ((Component)val).transform;
			if ((Object)(object)_panel == (Object)null)
			{
				EnsurePanel(basePage);
			}
			else
			{
				RefreshPanelLayout(basePage, transform);
			}
			UnitEditorManager val2 = Object.FindObjectOfType<UnitEditorManager>();
			if ((Object)(object)val2 != (Object)null && IsCurrentMovementFlee(val2))
			{
				TryApplyFromActiveBlueprint(val2);
			}
			RefreshPanelVisibility();
			RefreshPanelUi();
			LogPlacementOnce();
			return true;
		}

		private static void LogPlacementOnce()
		{
			//IL_009c: 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)
			if (!_loggedPlacement && !((Object)(object)_panel == (Object)null) && _panel.activeSelf)
			{
				UnitEditorManager val = Object.FindObjectOfType<UnitEditorManager>();
				if (!((Object)(object)val == (Object)null) && IsCurrentMovementFlee(val))
				{
					_loggedPlacement = true;
					RectTransform component = _panel.GetComponent<RectTransform>();
					string transformPath = UnitEditorUiText.GetTransformPath(_panel.transform.parent);
					string text = (((Object)(object)_lastResolvedIconRect != (Object)null) ? UnitEditorUiText.GetTransformPath((Transform)(object)_lastResolvedIconRect) : "none");
					Plugin.LogInfo($"Flee distance UI: parent={transformPath} strategy={_lastPlacementStrategy} icon={text} pos={component.anchoredPosition} size={component.sizeDelta} active=True");
				}
			}
		}

		private static void OnInputEndEdit(string rawValue)
		{
			if (!_updatingUi)
			{
				if (!TryParseDistance(rawValue, out var distance))
				{
					RefreshPanelUi();
				}
				else
				{
					ApplyFleeDistance(distance);
				}
			}
		}

		private static void AdjustFleeDistance(float delta)
		{
			ApplyFleeDistance(_fleeDistance + delta);
		}

		private static void ApplyFleeDistance(float distance)
		{
			_fleeDistance = FleeDistanceHelper.ClampDistance(distance);
			RefreshPanelUi();
			UnitEditorManager val = Object.FindObjectOfType<UnitEditorManager>();
			if ((Object)(object)val != (Object)null)
			{
				SyncLiveBlueprint(val);
			}
		}

		private static void RefreshPanelUi()
		{
			if ((Object)(object)_inputField == (Object)null)
			{
				return;
			}
			string text = FormatDistance(_fleeDistance);
			if (!(_inputField.text == text) || string.IsNullOrEmpty(_inputField.text))
			{
				_updatingUi = true;
				_inputField.text = text;
				if ((Object)(object)_inputField.textComponent != (Object)null)
				{
					_inputField.textComponent.text = text;
				}
				_updatingUi = false;
			}
		}

		private static bool TryParseDistance(string rawValue, out float distance)
		{
			distance = 0f;
			if (string.IsNullOrWhiteSpace(rawValue))
			{
				return false;
			}
			string text = rawValue.Trim();
			if (text.EndsWith("WM", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - 2).Trim();
			}
			return float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out distance);
		}

		private static string FormatDistance(float distance)
		{
			return distance.ToString("0.#", CultureInfo.InvariantCulture);
		}

		private static void RefreshPanelVisibility()
		{
			UnitEditorManager val = Object.FindObjectOfType<UnitEditorManager>();
			bool active = (Object)(object)val != (Object)null && IsCurrentMovementFlee(val);
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(active);
			}
		}

		private static bool IsPanelVisible()
		{
			if ((Object)(object)_panel != (Object)null)
			{
				return _panel.activeSelf;
			}
			return false;
		}

		private static void SyncLiveBlueprint(UnitEditorManager manager)
		{
			if (IsCurrentMovementFlee(manager))
			{
				if (TryGetEditorSpawnBlueprint(manager, out var blueprint))
				{
					FleeDistanceHelper.EnsureFleeDistanceComponent(blueprint, _fleeDistance);
				}
				object? obj = EditorLoadedUnitField?.GetValue(manager);
				UnitBlueprint val = (UnitBlueprint)((obj is UnitBlueprint) ? obj : null);
				if (val != null && (Object)(object)val != (Object)null)
				{
					FleeDistanceHelper.EnsureFleeDistanceComponent(val, _fleeDistance);
				}
			}
		}

		private static bool IsCurrentMovementFlee(UnitEditorManager manager)
		{
			if (!(MovementTypesComponentsField?.GetValue(manager) is List<IMovementComponent> list))
			{
				return false;
			}
			if (!(CurrentMovementTypeField?.GetValue(manager) is int num) || num < 0 || num >= list.Count)
			{
				return false;
			}
			return list[num] is FleeDistance;
		}

		private static bool IsMovementRowSelected(UnitEditorBasePageUI basePage)
		{
			object? obj = MovementTypeField?.GetValue(basePage);
			UnitEditorSelectableItem val = (UnitEditorSelectableItem)((obj is UnitEditorSelectableItem) ? obj : null);
			if (val == null)
			{
				return false;
			}
			EventSystem current = EventSystem.current;
			GameObject val2 = ((current != null) ? current.currentSelectedGameObject : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			if (!((Object)(object)val2 == (Object)(object)((Component)val).gameObject))
			{
				return val2.transform.IsChildOf(((Component)val).transform);
			}
			return true;
		}

		private static void StripMetadataFromDescriptionField(UnitEditorManager manager)
		{
			UnitEditorUIManager val = manager?.UIManager;
			if (!((Object)(object)val == (Object)null) && !(GetUnitDescriptionMethod == null) && !(SetUnitDescriptionMethod == null))
			{
				string obj = (GetUnitDescriptionMethod.Invoke(val, null) as string) ?? string.Empty;
				string text = FleeDistanceMetadata.Strip(obj);
				if (!string.Equals(obj, text, StringComparison.Ordinal))
				{
					SetUnitDescriptionMethod.Invoke(val, new object[1] { text });
				}
				object? obj2 = EditorLoadedUnitField?.GetValue(manager);
				UnitBlueprint val2 = (UnitBlueprint)((obj2 is UnitBlueprint) ? obj2 : null);
				if (val2 != null && (Object)(object)val2 != (Object)null)
				{
					val2.UnitDescription = FleeDistanceMetadata.Strip(val2.UnitDescription);
				}
			}
		}

		private static bool TryGetEditorSpawnBlueprint(UnitEditorManager manager, out UnitBlueprint blueprint)
		{
			blueprint = null;
			if ((Object)(object)manager == (Object)null)
			{
				return false;
			}
			if (!(EditorUnitBasesField?.GetValue(manager) is UnitBaseWrapper[] array) || !(EditorCurrentUnitBaseField?.GetValue(manager) is int num) || num < 0 || num >= array.Length)
			{
				return false;
			}
			blueprint = array[num].UnitBaseBlueprint;
			return (Object)(object)blueprint != (Object)null;
		}

		private static List<MovementTypeWrapper> BuildMovementTypeWrappers(MovementTypeWrapper[] existing, int componentCount)
		{
			//IL_0016: 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)
			List<MovementTypeWrapper> list = ((existing != null) ? new List<MovementTypeWrapper>(existing) : new List<MovementTypeWrapper>());
			while (list.Count < componentCount)
			{
				list.Add(default(MovementTypeWrapper));
			}
			if (list.Count > componentCount)
			{
				list.RemoveRange(componentCount, list.Count - componentCount);
			}
			return list;
		}

		private static bool HasFleeDistanceType(IReadOnlyList<IMovementComponent> components)
		{
			for (int i = 0; i < components.Count; i++)
			{
				if (components[i] is FleeDistance)
				{
					return true;
				}
			}
			return false;
		}

		private static int FindFleeDistanceIndex()
		{
			UnitEditorManager val = Object.FindObjectOfType<UnitEditorManager>();
			if (val?.MovementTypesComponents == null)
			{
				return -1;
			}
			for (int i = 0; i < val.MovementTypesComponents.Count; i++)
			{
				if (val.MovementTypesComponents[i] is FleeDistance)
				{
					return i;
				}
			}
			return -1;
		}

		private static Graphic CreateInputPlaceholder(Transform parent, string placeholderText)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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)
			GameObject val = new GameObject("Placeholder", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			StretchFull(val.GetComponent<RectTransform>(), 4f, 2f, -4f, -2f);
			Text obj = val.AddComponent<Text>();
			obj.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			obj.fontSize = 15;
			obj.fontStyle = (FontStyle)2;
			obj.alignment = (TextAnchor)4;
			((Graphic)obj).color = new Color(1f, 1f, 1f, 0.35f);
			obj.text = placeholderText;
			((Graphic)obj).raycastTarget = false;
			return (Graphic)(object)obj;
		}

		private static void StretchFull(RectTransform rect, float left, float bottom, float right, float top)
		{
			//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_0019: 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)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = new Vector2(left, bottom);
			rect.offsetMax = new Vector2(right, top);
		}

		private static void CleanupPanel()
		{
			if ((Object)(object)_panel != (Object)null)
			{
				Object.Destroy((Object)(object)_panel);
				_panel = null;
				_inputField = null;
			}
		}

		private static void StopLayoutCoroutine()
		{
			if (_layoutCoroutine != null && !((Object)(object)Plugin.Instance == (Object)null))
			{
				((MonoBehaviour)Plugin.Instance).StopCoroutine(_layoutCoroutine);
				_layoutCoroutine = null;
			}
		}
	}
	internal static class UnitEditorFootstepPicker
	{
		private static readonly FieldInfo ListSelectScreenField = AccessTools.Field(typeof(UnitEditorUIManager), "listSelectScreen");

		private static readonly FieldInfo ContentParentField = AccessTools.Field(typeof(UnitEditorListSelectScreen), "contentParent");

		private static readonly FieldInfo PrefabField = AccessTools.Field(typeof(UnitEditorListSelectScreen), "prefab");

		private static readonly FieldInfo SpawnedItemsField = AccessTools.Field(typeof(UnitEditorListSelectScreen), "spawnedItems");

		private static readonly FieldInfo HeaderField = AccessTools.Field(typeof(UnitEditorListSelectScreen), "header");

		private static readonly FieldInfo SearchFieldField = AccessTools.Field(typeof(UnitEditorListSelectScreen), "searchField");

		private static readonly MethodInfo ClearListMethod = AccessTools.Method(typeof(UnitEditorListSelectScreen), "ClearList", (Type[])null, (Type[])null);

		private static readonly MethodInfo SetupNavigationMethod = AccessTools.Method(typeof(UnitEditorListSelectScreen), "SetupNavigation", (Type[])null, (Type[])null);

		private static readonly MethodInfo SearchMethod = AccessTools.Method(typeof(UnitEditorListSelectScreen), "Search", (Type[])null, (Type[])null);

		private static readonly MethodInfo SetUiMethod = AccessTools.Method(typeof(UnitEditorListSelectScreen), "SetUI", (Type[])null, (Type[])null);

		private static readonly Type ListTypeEnum = AccessTools.Inner(typeof(UnitEditorListSelectScreen), "ListType");

		private static readonly FieldInfo VoiceCellTextField = AccessTools.Field(typeof(UnitEditorVoiceSelectCell), "m_text");

		private static readonly MethodInfo GetSelectableChildrenMethod = AccessTools.Method(AccessTools.TypeByName("UIHelpers"), "GetSelectableChildren", new Type[2]
		{
			typeof(Transform),
			typeof(bool)
		}, (Type[])null);

		private static readonly MethodInfo CreateExplicitLinearNavigationMethod = AccessTools.Method(AccessTools.TypeByName("UIHelpers"), "CreateExplicitLinearNavigation", (Type[])null, (Type[])null);

		internal static bool IsActive { get; private set; }

		internal static void Open()
		{
			if (!UnitEditorConfig.CustomFootstepsEnabled)
			{
				return;
			}
			UnitEditorFootstepDebug.Log("Open: starting footstep picker");
			FootstepIconResolver.WarmCache();
			UnitEditorUIManager val = Object.FindObjectOfType<UnitEditorUIManager>();
			if ((Object)(object)val == (Object)null)
			{
				Plugin.LogWarning("Unit footstep picker: UnitEditorUIManager not found");
				UnitEditorFootstepDebug.LogWarning("Open: UnitEditorUIManager not found");
				return;
			}
			object? obj = ListSelectScreenField?.GetValue(val);
			UnitEditorListSelectScreen val2 = (UnitEditorListSelectScreen)((obj is UnitEditorListSelectScreen) ? obj : null);
			if (val2 == null)
			{
				Plugin.LogWarning("Unit footstep picker: listSelectScreen not found");
				UnitEditorFootstepDebug.LogWarning("Open: listSelectScreen not found");
				return;
			}
			ClearListMethod?.Invoke(val2, null);
			IsActive = true;
			InvokeSetUi(val2);
			object? obj2 = ContentParentField?.GetValue(val2);
			Transform val3 = (Transform)((obj2 is Transform) ? obj2 : null);
			object? obj3 = PrefabField?.GetValue(val2);
			GameObject val4 = (GameObject)((obj3 is GameObject) ? obj3 : null);
			IList list = SpawnedItemsField?.GetValue(val2) as IList;
			UnitEditorFootstepDebug.Log(string.Format("Open: contentParent={0} prefab={1} ", (Object)(object)val3 != (Object)null, ((Object)(object)val4 != (Object)null) ? ((Object)val4).name : "null") + $"spawnedItems={list != null} catalogCount={FootstepCatalog.All.Length}");
			if ((Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null || list == null)
			{
				Plugin.LogWarning("Unit footstep picker: list screen fields missing");
				UnitEditorFootstepDebug.LogWarning("Open: list screen fields missing");
				IsActive = false;
				return;
			}
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < FootstepCatalog.All.Length; i++)
			{
				FootstepDef footstepDef = FootstepCatalog.All[i];
				GameObject val5 = Object.Instantiate<GameObject>(val4, val3);
				UnitEditorVoiceSelectCell component = val5.GetComponent<UnitEditorVoiceSelectCell>();
				if ((Object)(object)component == (Object)null)
				{
					num2++;
					UnitEditorFootstepDebug.LogWarning($"Open: cell {i} ({footstepDef.DisplayName}) has no UnitEditorVoiceSelectCell, skipping");
					Object.Destroy((Object)(object)val5);
					continue;
				}
				val5.SetActive(true);
				val5.AddComponent<FootstepSelectCellBinder>().Configure(component, footstepDef);
				list.Add(component);
				num++;
				object? obj4 = VoiceCellTextField?.GetValue(component);
				LocalizeText val6 = (LocalizeText)((obj4 is LocalizeText) ? obj4 : null);
				string text = (((Object)(object)val6 != (Object)null) ? UnitEditorUiText.GetLocalizeDisplayText(val6) : "(no m_text)");
				UnitEditorFootstepDebug.Log($"Open: cell {i} {footstepDef.DisplayName} activeSelf={val5.activeSelf} label=\"{text}\" m_text={(Object)(object)val6 != (Object)null}");
			}
			if (num == 0)
			{
				Plugin.LogWarning("Unit footstep picker: spawned 0 cells");
				UnitEditorFootstepDebug.LogWarning($"Open: spawned 0 cells (skipped={num2})");
			}
			else
			{
				UnitEditorFootstepDebug.Log($"Open: spawned {num} cells (skipped={num2})");
			}
			SetupNavigation(val2, val3);
			val.NavigateToPage("VOICESELECT");
			RefreshOpenState(val2);
		}

		internal static void OnListClosed()
		{
			IsActive = false;
			UnitEditorFootstepDebug.Log("OnListClosed");
		}

		public static void ListSelect_OnClose_Postfix()
		{
			OnListClosed();
		}

		public static void ListSelect_OnOpen_Postfix(UnitEditorListSelectScreen __instance)
		{
			if (IsActive)
			{
				UnitEditorFootstepDebug.Log("ListSelect_OnOpen_Postfix: footstep picker active, refreshing open state");
				RefreshOpenState(__instance);
			}
		}

		public static bool VoiceSelectCell_SelectVoice_Prefix(UnitEditorVoiceSelectCell __instance)
		{
			if (!UnitEditorConfig.CustomFootstepsEnabled)
			{
				return true;
			}
			FootstepSelectCellBinder component = ((Component)__instance).GetComponent<FootstepSelectCellBinder>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			component.SelectFootstep();
			return false;
		}

		public static bool VoiceSelectCell_ValidInFilter_Prefix(UnitEditorVoiceSelectCell __instance, string filter, ref bool __result)
		{
			if (!IsActive)
			{
				return true;
			}
			FootstepSelectCellBinder component = ((Component)__instance).GetComponent<FootstepSelectCellBinder>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			__result = component.MatchesFilter(filter);
			return false;
		}

		public static bool VoiceSelectCell_Play_Prefix(UnitEditorVoiceSelectCell __instance)
		{
			if (!UnitEditorConfig.CustomFootstepsEnabled)
			{
				return true;
			}
			FootstepSelectCellBinder component = ((Component)__instance).GetComponent<FootstepSelectCellBinder>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			component.PlayPreview();
			return false;
		}

		private static void InvokeSetUi(UnitEditorListSelectScreen listScreen)
		{
			if (SetUiMethod == null || ListTypeEnum == null)
			{
				UnitEditorFootstepDebug.LogWarning("InvokeSetUi: SetUI or ListType enum not found");
				return;
			}
			object obj = Enum.Parse(ListTypeEnum, "VoiceBundles");
			SetUiMethod.Invoke(listScreen, new object[1] { obj });
			UnitEditorFootstepDebug.Log("InvokeSetUi: SetUI(VoiceBundles) invoked");
		}

		private static void RefreshOpenState(UnitEditorListSelectScreen listScreen)
		{
			SetHeader(listScreen, "UNIT FOOTSTEP");
			SearchMethod?.Invoke(listScreen, new object[1] { string.Empty });
			IList list = SpawnedItemsField?.GetValue(listScreen) as IList;
			int num = list?.Count ?? 0;
			string searchFieldText = GetSearchFieldText(listScreen);
			bool flag = false;
			if (list != null && list.Count > 0)
			{
				object? obj = list[0];
				Component val = (Component)((obj is Component) ? obj : null);
				if (val != null)
				{
					flag = val.gameObject.activeSelf;
				}
			}
			UnitEditorFootstepDebug.Log($"RefreshOpenState: spawnedCount={num} searchField=\"{searchFieldText}\" firstCellActive={flag}");
		}

		private static string GetSearchFieldText(UnitEditorListSelectScreen listScreen)
		{
			if (SearchFieldField?.GetValue(listScreen) == null)
			{
				return "(null)";
			}
			object value = SearchFieldField.GetValue(listScreen);
			return (value.GetType().GetProperty("text")?.GetValue(value) as string) ?? string.Empty;
		}

		private static void SetHeader(UnitEditorListSelectScreen listScreen, string label)
		{
			object? obj = HeaderField?.GetValue(listScreen);
			LocalizeText val = (LocalizeText)((obj is LocalizeText) ? obj : null);
			if (val == null)
			{
				UnitEditorFootstepDebug.LogWarning("SetHeader: header field is null");
			}
			else
			{
				UnitEditorUiText.SetRawLocalizeText(val, label);
			}
		}

		private static void SetupNavigation(UnitEditorListSelectScreen listScreen, Transform contentParent)
		{
			if (SetupNavigationMethod != null)
			{
				SetupNavigationMethod.Invoke(listScreen, null);
			}
			else if (!(GetSelectableChildrenMethod == null) && !(CreateExplicitLinearNavigationMethod == null))
			{
				object obj = GetSelectableChildrenMethod.Invoke(null, new object[2] { contentParent, false });
				CreateExplicitLinearNavigationMethod.Invoke(null, new object[2] { obj, false });
			}
		}
	}
	internal sealed class FootstepSelectCellBinder : MonoBehaviour
	{
		private FootstepDef _def;

		private UnitEditorVoiceSelectCell _cell;

		internal void Configure(UnitEditorVoiceSelectCell cell, FootstepDef def)
		{
			_cell = cell;
			_def = def;
			ClearSubmitHandlers((UnitEditorSelectableItem)(object)cell);
			SetLabel(cell, def.DisplayName);
			SetIcon(cell, def);
			WirePreview(cell);
			WireCorrespondingButton(cell);
			WireSubmitEvent(cell);
			((UnitEditorSelectableItem)cell).Submitted += OnSubmitted;
			bool flag = AccessTools.Field(typeof(UnitEditorVoiceSelectCell), "previewButton")?.GetValue(cell) != null;
			bool flag2 = AccessTools.Field(typeof(UnitEditorSelectableItem), "correspondingButton")?.GetValue(cell) != null;
			UnitEditorFootstepDebug.Log($"Configure: {def.DisplayName} previewButton={flag} correspondingButton={flag2}");
		}

		internal bool MatchesFilter(string filter)
		{
			if (string.IsNullOrEmpty(filter))
			{
				return true;
			}
			return (_def?.DisplayName ?? string.Empty).IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private void OnDestroy()
		{
			if ((Object)(object)_cell != (Object)null)
			{
				((UnitEditorSelectableItem)_cell).Submitted -= OnSubmitted;
			}
		}

		private void OnSubmitted(UnitEditorSelectableItem _)
		{
			SelectFootstep();
		}

		internal void SelectFootstep()
		{
			UnitEditorFootstepDebug.Log("SelectFootstep: " + _def?.DisplayName + " (" + _def?.AudioRef + ")");
			UnitEditorCustomFootsteps.SetCurrentFootstep(_def);
			UnitEditorManager obj = Object.FindObjectOfType<UnitEditorManager>();
			if (obj != null)
			{
				UnitEditorUIManager uIManager = obj.UIManager;
				if (uIManager != null)
				{
					uIManager.NavigateToPage("UNIT");
				}
			}
			UnitEditorFootstepPicker.OnListClosed();
		}

		internal void PlayPreview()
		{
			if (_def != null)
			{
				FootstepBlueprintHelper.PlayPreviewSound(_def.AudioRef, UnitEditorCustomFootsteps.GetCurrentFootPitch());
			}
		}

		private static void ClearSubmitHandlers(UnitEditorSelectableItem item)
		{
			object? obj = AccessTools.Field(typeof(UnitEditorSelectableItem), "onSubmitEvent")?.GetValue(item);
			UnityEvent val = (UnityEvent)((obj is UnityEvent) ? obj : null);
			if (val != null)
			{
				((UnityEventBase)val).RemoveAllListeners();
			}
		}

		private static void WireSubmitEvent(UnitEditorVoiceSelectCell cell)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			object? obj = AccessTools.Field(typeof(UnitEditorSelectableItem), "onSubmitEvent")?.GetValue(cell);
			UnityEvent val = (UnityEvent)((obj is UnityEvent) ? obj : null);
			if (val != null)
			{
				((UnityEventBase)val).RemoveAllListeners();
				FootstepSelectCellBinder binder = ((Component)cell).GetComponent<FootstepSelectCellBinder>();
				val.AddListener((UnityAction)delegate
				{
					binder?.SelectFootstep();
				});
			}
		}

		private static void WireCorrespondingButton(UnitEditorVoiceSelectCell cell)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			object? obj = AccessTools.Field(typeof(UnitEditorSelectableItem), "correspondingButton")?.GetValue(cell);
			Button val = (Button)((obj is Button) ? obj : null);
			if (val != null)
			{
				FootstepSelectCellBinder binder = ((Component)cell).GetComponent<FootstepSelectCellBinder>();
				UnitEditorUiText.ReplaceButtonClick(val, (UnityAction)delegate
				{
					binder?.SelectFootstep();
				});
			}
		}

		private static void SetLabel(UnitEditorVoiceSelectCell cell, string label)
		{
			object? obj = AccessTools.Field(typeof(UnitEditorVoiceSelectCell), "m_text")?.GetValue(cell);
			LocalizeText val = (LocalizeText)((obj is LocalizeText) ? obj : null);
			if (val != null)
			{
				UnitEditorUiText.SetRawLocalizeText(val, label);
			}
		}

		private static void SetIcon(UnitEditorVoiceSelectCell cell, FootstepDef def)
		{
			if (!((Object)(object)cell.m_image == (Object)null))
			{
				Sprite icon = FootstepIconResolver.GetIcon(def);
				cell.m_image.sprite = icon;
				((Component)cell.m_image).gameObject.SetActive((Object)(object)icon != (Object)null);
			}
		}

		private static void WirePreview(UnitEditorVoiceSelectCell cell)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			object? obj = AccessTools.Field(typeof(UnitEditorVoiceSelectCell), "previewButton")?.GetValue(cell);
			Button val = (Button)((obj is Button) ? obj : null);
			if (val != null)
			{
				FootstepSelectCellBinder binder = ((Component)cell).GetComponent<FootstepSelectCellBinder>();
				UnitEditorUiText.ReplaceButtonClick(val, (UnityAction)delegate
				{
					binder?.PlayPreview();
				});
			}
		}
	}
	internal static class UnitEditorMoveWhileTurning
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__ToggleMoveWhileTurning;
		}

		[CompilerGenerated]
		private sealed class <DeferredEnsureButton>d__38 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public UnitEditorBasePageUI basePage;

			public Transform movementRoot;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DeferredEnsureButton>d__38(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					_layoutCoroutine = null;
					CleanupLegacyRows(basePage);
					ClearDestroyedButtonRefs();
					if (TryEnsureButtonOnPage(basePage, movementRoot))
					{
						RefreshButtonUi();
						UnitEditorBasePageScroll.ScheduleSetup(basePage);
						ScheduleLayoutRefresh(basePage, movementRoot);
					}
					else
					{
						Plugin.LogWarning("Move while turning button: movement value row not found");
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <RefreshButtonLayoutAfterOpen>d__51 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public UnitEditorBasePageUI basePage;

			public Transform movementRoot;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RefreshButtonLayoutAfterOpen>d__51(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Expected O, but got Unknown
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
				{
					<>1__state = -1;
					_layoutCoroutine = null;
					ClearDestroyedButtonRefs();
					Transform val = FindMovementNameRow(basePage, movementRoot);
					if (!((Object)val == (Object)null))
					{
						RemoveDuplicateButtons(movementRoot, val);
						if (!TryBindExistingButton(basePage, movementRoot, val))
						{
							TryCreateButton(basePage, movementRoot, val);
							RefreshButtonUi();
						}
					}
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		internal const string ButtonName = "TabsUnlimited_MoveWhileTurningButton";

		private const string LegacyRowName = "TabsUnlimited_MoveWhileTurningRow";

		private const string VoiceNameRowHint = "UnitVoiceName";

		private static readonly Color ButtonBackground = new Color(0.08f, 0.08f, 0.08f, 0.95f);

		private static readonly Vector2 DefaultButtonSize = new Vector2(236f, 52f);

		private static readonly Vector2 DefaultAnchorPosition = new Vector2(-8f, 0f);

		private static readonly Vector2 MovementNameRowAnchorPosition = new Vector2(480f, 0f);

		private const float MovementValueVerticalOffset = 52f;

		private static readonly FieldInfo MovementTypeField = AccessTools.Field(typeof(UnitEditorBasePageUI), "movementType");

		private static readonly FieldInfo VoiceSelectField = AccessTools.Field(typeof(UnitEditorBasePageUI), "voiceSelect");

		private static readonly FieldInfo ContentParentField = AccessTools.Field(typeof(UnitEditorBasePageUI), "contentParent");

		private static readonly FieldInfo EditorUnitBasesField = AccessTools.Field(typeof(UnitEditorManager), "UnitBases");

		private static readonly FieldInfo EditorCurrentUnitBaseField = AccessTools.Field(typeof(UnitEditorManager), "currentUnitBase");

		private static readonly FieldInfo EditorSpawnedBaseField = AccessTools.Field(typeof(UnitEditorManager), "spawnedBase");

		private static readonly FieldInfo EditorLoadedUnitField = AccessTools.Field(typeof(UnitEditorManager), "loadedUnit");

		private static readonly FieldInfo MovementTypesComponentsField = AccessTools.Field(typeof(UnitEditorManager), "MovementTypesComponents");

		private static readonly FieldInfo CurrentMovementTypeField = AccessTools.Field(typeof(UnitEditorManager), "currentMovementType");

		private static readonly MethodInfo GetUnitDescriptionMethod = AccessTools.Method(typeof(UnitEditorUIManager), "GetUnitDescrption", (Type[])null, (Type[])null);

		private static readonly MethodInfo SetUnitDescriptionMethod = AccessTools.Method(typeof(UnitEditorUIManager), "SetDescription", (Type[])null, (Type[])null);

		private static Button _toggleButton;

		private static Text _toggleLabel;

		private static Coroutine _layoutCoroutine;

		private static bool _moveWhileTurning;

		private static bool _explicitlySet;

		public static void BasePage_Open_Postfix(UnitEditorBasePageUI __instance)
		{
			if (!UnitEditorConfig.MoveWhileTurningEnabled)
			{
				CleanupButton(__instance);
				return;
			}
			CleanupLegacyRows(__instance);
			EnsureButton(__instance);
			RefreshButtonUi();
		}

		public static void BasePage_Close_Postfix(UnitEditorBasePageUI __instance)
		{
			StopLayoutCoroutine();
			UnitEditorBasePageScroll.Cleanup(__instance);
		}

		public static void UIManager_Start_Prefix(UnitEditorUIManager __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			if (UnitEditorConfig.MoveWhileTurningEnabled)
			{
				UnitEditorBasePageUI val = Object.FindObjectOfType<UnitEditorBasePageUI>();
				if (!((Object)val == (Object)null))
				{
					EnsureButton(val);
				}
			}
		}

		public static void LoadUnit_Postfix(UnitEditorManager __instance, UnitBlueprint blueprint)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			if (UnitEditorConfig.MoveWhileTurningEnabled && !((Object)blueprint == (Object)null))
			{
				ApplyFromBlueprint(blueprint);
				SyncLiveUnit(__instance);
				StripMetadataFromDescriptionField(__instance);
			}
		}

		public static void ClearUnit_Postfix()
		{
			if (UnitEditorConfig.MoveWhileTurningEnabled)
			{
				_moveWhileTurning = false;
				_explicitlySet = false;
				RefreshButtonUi();
			}
		}

		public static void GetBlueprint_Postfix(UnitEditorManager __instance, ref UnitBlueprint __result)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			if (UnitEditorConfig.MoveWhileTurningEnabled && !((Object)__result == (Object)null) && _explicitlySet)
			{
				MoveWhileTurningHelper.SetExplicit(__result, _moveWhileTurning);
			}
		}

		public static void SelectMovementType_Postfix(UnitEditorManager __instance)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			if (UnitEditorConfig.MoveWhileTurningEnabled && !((Object)__instance == (Object)null))
			{
				if (_explicitlySet)
				{
					RefreshButtonUi();
					SyncLiveUnit(__instance);
				}
				else
				{
					_moveWhileTurning = IsCurrentMovementNeverStop(__instance);
					RefreshButtonUi();
					SyncLiveUnit(__instance);
				}
			}
		}

		public static void RespawnUnit_Postfix(UnitEditorManager __instance)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			if (UnitEditorConfig.MoveWhileTurningEnabled && !((Object)__instance == (Object)null))
			{
				SyncLiveUnit(__instance);
			}
		}

		public static void SerializedUnit_Postfix(UnitBlueprint __instance, ref SerializedUnitBlueprint __result)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			if (UnitEditorConfig.MoveWhileTurningEnabled && !((Object)__instance == (Object)null) && __result != null)
			{
				bool implicitNeverStop = MoveWhileTurningHelper.IsNeverStopRunningMovement(__instance.MovementComponents);
				bool enabled = MoveWhileTurningHelper.ResolveForSave(__instance, _moveWhileTurning, _explicitlySet);
				__result.unitDescription = MoveWhileTurningMetadata.EmbedForSave(__result.unitDescription, enabled, implicitNeverStop);
			}
		}

		public static void DeserializedUnit_Postfix(SerializedUnitBlueprint data, ref UnitBlueprint __result)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			if (UnitEditorConfig.MoveWhileTurningEnabled && data != null && !((Object)__result == (Object)null))
			{
				MoveWhileTurningHelper.ApplyFromSerializedDescription(__result, data.unitDescription);
				if (MoveWhileTurningMetadata.TryParse(data.unitDescription, out var _, out var cleanDescription))
				{
					__result.UnitDescription = cleanDescription;
				}
			}
		}

		internal static void ApplyFromBlueprint(UnitBlueprint blueprint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if (!((Object)blueprint == (Object)null))
			{
				if (MoveWhileTurningHelper.TryGetExplicit(blueprint, out var enabled))
				{
					_moveWhileTurning = enabled;
					_explicitlySet = true;
				}
				else
				{
					_moveWhileTurning = MoveWhileTurningHelper.ShouldMoveWhileTurning(blueprint);
					_explicitlySet = false;
				}
				RefreshButtonUi();
			}
		}

		private static void EnsureButton(UnitEditorBasePageUI basePage)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			object obj = MovementTypeField?.GetValue(basePage);
			UnitEditorSelectableItem val = (UnitEditorSelectableItem)((obj is UnitEditorSelectableItem) ? obj : null);
			if ((Object)(object)val != (Object)null)
			{
				ClearDestroyedButtonRefs();
				Transform transform = ((Component)val).transform;
				if (TryEnsureButtonOnPage(basePage, transform))
				{
					UnitEditorBasePageScroll.ScheduleSetup(basePage);
					ScheduleLayoutRefresh(basePage, transform);
				}
				else
				{
					ScheduleDeferredEnsure(basePage, transform);
				}
			}
		}

		private static bool TryEnsureButtonOnPage(UnitEditorBasePageUI basePage, Transform movementRoot)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			Transform val = FindMovementNameRow(basePage, movementRoot);
			if ((Object)val == (Object)null)
			{
				return false;
			}
			RemoveDuplicateButtons(movementRoot, val);
			if (TryBindExistingButton(basePage, movementRoot, val))
			{
				return true;
			}
			return TryCreateButton(basePage, movementRoot, val);
		}

		private static void ScheduleDeferredEnsure(UnitEditorBasePageUI basePage, Transform movementRoot)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if (!((Object)Plugin.Instance == (Object)null))
			{
				StopLayoutCoroutine();
				_layoutCoroutine = ((MonoBehaviour)Plugin.Instance).StartCoroutine(DeferredEnsureButton(basePage, movementRoot));
			}
		}

		[IteratorStateMachine(typeof(<DeferredEnsureButton>d__38))]
		private static IEnumerator DeferredEnsureButton(UnitEditorBasePageUI basePage, Transform movementRoot)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DeferredEnsureButton>d__38(0)
			{
				basePage = basePage,
				movementRoot = movementRoot
			};
		}

		private static bool TryBindExistingButton(UnitEditorBasePageUI basePage, Transform movementRoot, Transform anchor)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//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_006d: Expected O, but got Unknown
			Transform val = FindExistingButton(movementRoot);
			if ((Object)val == (Object)null)
			{
				return false;
			}
			Button component = ((Component)val).GetComponent<Button>();
			Text componentInChildren = ((Component)val).GetComponentInChildren<Text>();
			if ((Object)component == (Object)null || (Object)componentInChildren == (Object)null)
			{
				return false;
			}
			ReparentButtonToAnchor(val, anchor);
			ApplyButtonLayout(basePage, val);
			object obj = <>O.<0>__ToggleMoveWhileTurning;
			if (obj == null)
			{
				UnityAction val2 = ToggleMoveWhileTurning;
				<>O.<0>__ToggleMoveWhileTurning = val2;
				obj = (object)val2;
			}
			UnitEditorUiText.ReplaceButtonClick(component, (UnityAction)obj);
			_toggleButton = component;
			_toggleLabel = componentInChildren;
			RefreshButtonUi();
			return true;
		}

		private static bool TryCreateButton(UnitEditorBasePageUI basePage, Transform movementRoot, Transform anchor)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			if ((Object)FindExistingButton(movementRoot) != (Object)null)
			{
				return TryBindExistingButton(basePage, movementRoot, anchor);
			}
			GameObject val = CreateButtonObject(anchor);
			ApplyButtonLayout(basePage, val.transform);
			_toggleButton = val.GetComponent<Button>();
			_toggleLabel = val.GetComponentInChildren<Text>();
			RefreshButtonUi();
			if ((Object)_toggleButton != (Object)null)
			{
				return (Object)_toggleLabel != (Object)null;
			}
			return false;
		}

		private static GameObject CreateButtonObject(Transform anchor)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_004b: 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_00f6: 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_0108: 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_011d: 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_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_0076: Expected O, but got Unknown
			GameObject val = new GameObject("TabsUnlimited_MoveWhileTurningButton", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(anchor, false);
			((Graphic)val.GetComponent<Image>()).color = ButtonBackground;
			Button component = val.GetComponent<Button>();
			object obj = <>O.<0>__ToggleMoveWhileTurning;
			if (obj == null)
			{
				UnityAction val2 = ToggleMoveWhileTurning;
				<>O.<0>__ToggleMoveWhileTurning = val2;
				obj = (object)val2;
			}
			UnitEditorUiText.ReplaceButtonClick(component, (UnityAction)obj);
			LayoutElement obj2 = val.AddComponent<LayoutElement>();
			obj2.ignoreLayout = true;
			obj2.minWidth = DefaultButtonSize.x;
			obj2.preferredWidth = DefaultButtonSize.x;
			obj2.minHeight = DefaultButtonSize.y;
			obj2.preferredHeight = DefaultButtonSize.y;
			GameObject val3 = new GameObject("Label", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(val.transform, false);
			RectTransform component2 = val3.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			Text obj3 = val3.AddComponent<Text>();
			obj3.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			obj3.fontSize = 18;
			obj3.alignment = (TextAnchor)4;
			((Graphic)obj3).color = Color.white;
			obj3.text = "Turning: OFF";
			return val;
		}

		private static void ApplyButtonLayout(UnitEditorBasePageUI basePage, Transform buttonTransform)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_0024: 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_0081: Expected O, but got Unknown
			//IL_005b: 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_00a9: 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_00cb: 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_00ed: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)buttonTransform).GetComponent<RectTransform>();
			ApplyDefaultButtonLayout(component);
			RectTransform val = FindVoiceButtonTemplate(basePage);
			if ((Object)val != (Object)null)
			{
				component.sizeDelta = val.sizeDelta;
			}
			if ((Object)buttonTransform.parent != (Object)null && ((Object)buttonTransform.parent).name.IndexOf("UnitVoiceName", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				component.anchoredPosition = MovementNameRowAnchorPosition;
			}
			else
			{
				AlignButtonToMovementValue(buttonTransform, component);
			}
			LayoutElement val2 = ((Component)buttonTransform).GetComponent<LayoutElement>();
			if ((Object)val2 == (Object)null)
			{
				val2 = ((Component)buttonTransform).gameObject.AddComponent<LayoutElement>();
			}
			val2.ignoreLayout = true;
			val2.minWidth = component.sizeDelta.x;
			val2.preferredWidth = component.sizeDelta.x;
			val2.minHeight = component.sizeDelta.y;
			val2.preferredHeight = component.sizeDelta.y;
			Image component2 = ((Component)buttonTransform).GetComponent<Image>();
			if ((Object)component2 != (Object)null)
			{
				((Graphic)component2).color = ButtonBackground;
			}
			buttonTransform.SetAsLastSibling();
		}

		internal static Transform FindMovementNameRow(UnitEditorBasePageUI basePage, Transform movementRoot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			if ((Object)movementRoot == (Object)null)
			{
				return null;
			}
			Transform val = TryMirrorVoiceNameRow(basePage, movementRoot);
			if ((Object)val != (Object)null)
			{
				return val;
			}
			Transform val2 = FindTransformByName(movementRoot, "UnitVoiceName");
			if ((Object)val2 != (Object)null)
			{
				return val2;
			}
			return movementRoot;
		}

		private static void AlignButtonToMovementValue(Transform buttonTransform, RectTransform buttonRect)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//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)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_00c8: 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_00cf: 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_00e9: 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_008c: Expected O, but got Unknown
			Transform parent = buttonTransform.parent;
			RectTransform val = (RectTransform)((parent is RectTransform) ? parent : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Transform val2 = FindTransformByName(buttonTransform.parent, "UnitVoiceName");
			RectTransform val3 = (RectTransform)((val2 is RectTransform) ? val2 : null);
			if ((Object)val3 == (Object)null)
			{
				LocalizeText val4 = FindMovementValueText(buttonTransform.parent);
				Transform val5 = (((Object)(object)val4 != (Object)null) ? ((Component)val4).transform : null);
				RectTransform val6 = (RectTransform)((val5 is RectTransform) ? val5 : null);
				if ((Object)(object)val6 != (Object)null)
				{
					val3 = val6;
				}
			}
			if (!((Object)val3 == (Object)null))
			{
				RectTransform val7 = val3;
				Rect rect = val3.rect;
				Vector3 val8 = ((Transform)val7).TransformPoint(Vector2.op_Implicit(((Rect)(ref rect)).center));
				Vector3 val9 = ((Transform)val).InverseTransformPoint(val8);
				buttonRect.anchoredPosition = new Vector2(DefaultAnchorPosition.x, val9.y + 52f);
			}
		}

		private static LocalizeText FindMovementValueText(Transform movementRoot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			if ((Object)movementRoot == (Object)null)
			{
				return null;
			}
			LocalizeText[] componentsInChildren = ((Component)movementRoot).GetComponentsInChildren<LocalizeText>(true);
			foreach (LocalizeText val in componentsInChildren)
			{
				if (!IsSectionHeader(UnitEditorUiText.GetLocaleId(val), UnitEditorUiText.GetLocalizeDisplayText(val)))
				{
					return val;
				}
			}
			return null;
		}

		private static Transform TryMirrorVoiceNameRow(UnitEditorBasePageUI basePage, Transform movementRoot)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			object obj = VoiceSelectField?.GetValue(basePage);
			UnitEditorSelectableVoiceItem val = (UnitEditorSelectableVoiceItem)((obj is UnitEditorSelectableVoiceItem) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Transform val2 = FindTransformByName(((Component)val).transform, "UnitVoiceName");
			if ((Object)val2 == (Object)null)
			{
				return null;
			}
			string relativeNamePath = GetRelativeNamePath(((Component)val).transform, val2);
			if (string.IsNullOrEmpty(relativeNamePath))
			{
				return null;
			}
			return ResolveRelativeNamePath(movementRoot, relativeNamePath);
		}

		internal static RectTransform TryMirrorVoiceIconRect(UnitEditorBasePageUI basePage, Transform movementRoot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			if ((Object)movementRoot == (Object)null || (Object)(object)basePage == (Object)null)
			{
				return null;
			}
			object obj = VoiceSelectField?.GetValue(basePage);
			UnitEditorSelectableVoiceItem val = (UnitEditorSelectableVoiceItem)((obj is UnitEditorSelectableVoiceItem) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Transform val2 = FindTransformByName(((Component)val).transform, "UnitVoiceIcon");
			if ((Object)val2 == (Object)null)
			{
				return null;
			}
			string relativeNamePath = GetRelativeNamePath(((Component)val).transform, val2);
			if (string.IsNullOrEmpty(relativeNamePath))
			{
				return null;
			}
			Transform val3 = ResolveRelativeNamePath(movementRoot, relativeNamePath);
			if ((Object)val3 == (Object)null || !((Component)val3).gameObject.activeInHierarchy)
			{
				return null;
			}
			Transform val4 = val3;
			while ((Object)(object)val4 != (Object)null && (Object)(object)val4 != (Object)(object)movementRoot)
			{
				if (((Object)val4).name.IndexOf("Cheat", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return null;
				}
				val4 = val4.parent;
			}
			return (RectTransform)(object)((val3 is RectTransform) ? val3 : null);
		}

		private static void ApplyDefaultButtonLayout(RectTransform rect)
		{
			//IL_000b: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(1f, 0.5f);
			rect.anchorMax = new Vector2(1f, 0.5f);
			rect.pivot = new Vector2(1f, 0.5f);
			rect.anchoredPosition = DefaultAnchorPosition;
			rect.sizeDelta = DefaultButtonSize;
			((Transform)rect).localScale = Vector3.one;
			((Transform)rect).localRotation = Quaternion.identity;
		}

		private static RectTransform FindVoiceButtonTemplate(UnitEditorBasePageUI basePage)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			object obj = VoiceSelectField?.GetValue(basePage);
			UnitEditorSelectableVoiceItem val = (UnitEditorSelectableVoiceItem)((obj is UnitEditorSelectableVoiceItem) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Transform[] componentsInChildren = ((Component)val).GetComponentsInChildren<Transform>(true);
			foreach (Transform val2 in componentsInChildren)
			{
				if (!(((Object)val2).name != "TabsUnlimited_CustomVoiceButton"))
				{
					return ((Component)val2).GetComponent<RectTransform>();
				}
			}
			return null;
		}

		private static void ScheduleLayoutRefresh(UnitEditorBasePageUI basePage, Transform movementRoot)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if (!((Object)Plugin.Instance == (Object)null))
			{
				StopLayoutCoroutine();
				_layoutCoroutine = ((MonoBehaviour)Plugin.Instance).StartCoroutine(RefreshButtonLayoutAfterOpen(basePage, movementRoot));
			}
		}

		[IteratorStateMachine(typeof(<RefreshButtonLayoutAfterOpen>d__51))]
		private static IEnumerator RefreshButtonLayoutAfterOpen(UnitEditorBasePageUI basePage, Transform movementRoot)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RefreshButtonLayoutAfterOpen>d__51(0)
			{
				basePage = basePage,
				movementRoot = movementRoot
			};
		}

		private static void CopyRectTransform(RectTransform source, RectTransform target)
		{
			//IL_0002: 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_001a: 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_0032: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			target.anchorMin = source.anchorMin;
			target.anchorMax = source.anchorMax;
			target.pivot = source.pivot;
			target.anchoredPosition = source.anchoredPosition;
			target.sizeDelta = source.sizeDelta;
			((Transform)target).localScale = Vector3.one;
			((Transform)target).localRotation = Quaternion.identity;
		}

		private static void ReparentButtonToAnchor(Transform buttonTransform, Transform anchor)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0022: 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_0032: Expected O, but got Unknown
			//IL_0032: Expected O, but got Unknown
			if (!((Object)buttonTransform == (Object)null) && !((Object)anchor == (Object)null) && (Object)buttonTransform.parent != (Object)anchor)
			{
				buttonTransform.SetParent(anchor, false);
			}
		}

		private static Transform ResolveValueRowContainer(Transform node, Transform selectableRoot)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_006a: 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_007a: Expected O, but got Unknown
			//IL_007a: Expected O, but got Unknown
			//IL_0052: 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_0062: Expected O, but got Unknown
			//IL_0062: Expected O, but got Unknown
			//IL_0028: 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: Expected O, but got Unknown
			//IL_0038: Expected O, but got Unknown
			if ((Object)node == (Object)null || (Object)selectableRoot == (Object)null)
			{
				return null;
			}
			Transform val = node;
			while ((Object)val != (Object)null && (Object)val != (Object)selectableRoot)
			{
				if ((Object)val.parent == (Object)selectableRoot)
				{
					return val;
				}
				val = val.parent;
			}
			if (!((Object)node.parent == (Object)selectableRoot))
			{
				return null;
			}
			return node;
		}

		private static Transform FindValueRowContainer(Transform movementRoot)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			LocalizeText[] componentsInChildren = ((Component)movementRoot).GetComponentsInChildren<LocalizeText>(true);
			foreach (LocalizeText val in componentsInChildren)
			{
				if (!IsSectionHeader(UnitEditorUiText.GetLocaleId(val), UnitEditorUiText.GetLocalizeDisplayText(val)))
				{
					Transform val2 = ResolveValueRowContainer(((Component)val).transform, movementRoot);
					if ((Object)val2 != (Object)null)
					{
						return val2;
					}
				}
			}
			return FindDirectValueRowChild(movementRoot);
		}

		private static Transform FindDirectValueRowChild(Transform movementRoot)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			for (int i = 0; i < movementRoot.childCount; i++)
			{
				Transform child = movementRoot.GetChild(i);
				if (!RowIsSectionHeader(child) && (Object)((Component)child).GetComponentInChildren<LocalizeText>(true) != (Object)null)
				{
					return child;
				}
			}
			LocalizeText[] componentsInChildren = ((Component)movementRoot).GetComponentsInChildren<LocalizeText>(true);
			foreach (LocalizeText val in componentsInChildren)
			{
				string localeId = UnitEditorUiText.GetLocaleId(val);
				string localizeDisplayText = UnitEditorUiText.GetLocalizeDisplayText(val);
				if (!IsSectionHeader(localeId, localizeDisplayText))
				{
					return ((Component)val).transform.parent ?? ((Component)val).transform;
				}
			}
			return null;
		}

		private static bool RowIsSectionHeader(Transform row)
		{
			LocalizeText[] componentsInChildren = ((Component)row).GetComponentsInChildren<LocalizeText>(true);
			foreach (LocalizeText localize in componentsInChildren)
			{
				if (IsSectionHeader(UnitEditorUiText.GetLocaleId(localize), UnitEditorUiText.GetLocalizeDisplayText(localize)))
				{
					return true;
				}
			}
			return false;
		}

		private static string GetRelativeNamePath(Transform root, Transform target)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0054: 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_0064: Expected O, but got Unknown
			//IL_0064: Expected O, but got Unknown
			if ((Object)root == (Object)null || (Object)target == (Object)null || !target.IsChildOf(root))
			{
				return null;
			}
			List<string> list = new List<string>();
			Transform val = target;
			while ((Object)val != (Object)null && (Object)val != (Object)root)
			{
				list.Insert(0, ((Object)val).name);
				val = val.parent;
			}
			if (list.Count != 0)
			{
				return string.Join("/", list);
			}
			return null;
		}

		private static Transform ResolveRelativeNamePath(Transform root, string relativePath)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			if ((Object)root == (Object)null || string.IsNullOrEmpty(relativePath))
			{
				return null;
			}
			string[] array = relativePath.Split(new char[1] { '/' });
			Transform val = root;
			for (int i = 0; i < array.Length; i++)
			{
				Transform val2 = null;
				for (int j = 0; j < val.childCount; j++)
				{
					Transform child = val.GetChild(j);
					if (!(((Object)child).name != array[i]))
					{
						val2 = child;
						break;
					}
				}
				if ((Object)val2 == (Object)null)
				{
					return null;
				}
				val = val2;
			}
			return val;
		}

		private static Transform FindTransformByName(Transform root, string targetName)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (((Object)root).name.IndexOf(targetName, StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return root;
			}
			for (int i = 0; i < root.childCount; i++)
			{
				Transform val = FindTransformByName(root.GetChild(i), targetName);
				if ((Object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static bool IsSectionHeader(string localeId, string display)
		{
			if (localeId.IndexOf("PITCH", StringComparison.OrdinalIgnoreCase) >= 0 || display.IndexOf("PITCH", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			if (localeId.IndexOf("UNITMOVEMENT", StringComparison.OrdinalIgnoreCase) >= 0 || localeId.IndexOf("MOVEMENTTYPE", StringComparison.OrdinalIgnoreCase) >= 0 || display.IndexOf("movement type", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			if (localeId.IndexOf("UNITVOICE", StringComparison.OrdinalIgnoreCase) < 0 && display.IndexOf("unit voice", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return display.IndexOf("unit footstep", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static void RemoveDuplicateButtons(Transform movementRoot, Transform preferredAnchor)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0038: 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_0048: Expected O, but got Unknown
			//IL_0048: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			Transform val = null;
			Transform[] componentsInChildren = ((Component)movementRoot).GetComponentsInChildren<Transform>(true);
			foreach (Transform val2 in componentsInChildren)
			{
				if (!(((Object)val2).name != "TabsUnlimited_MoveWhileTurningButton"))
				{
					if ((Object)val == (Object)null && (Object)val2.parent == (Object)preferredAnchor)
					{
						val = val2;
					}
					else
					{
						Object.Destroy((Object)((Component)val2).gameObject);
					}
				}
			}
			if ((Object)val != (Object)null)
			{
				return;
			}
			componentsInChildren = ((Component)movementRoot).GetComponentsInChildren<Transform>(true);
			foreach (Transform val3 in componentsInChildren)
			{
				if (!(((Object)val3).name != "TabsUnlimited_MoveWhileTurningButton"))
				{
					if ((Object)val == (Object)null)
					{
						val = val3;
					}
					else
					{
						Object.Destroy((Object)((Component)val3).gameObject);
					}
				}
			}
		}

		internal static RectTransform TryGetTurningButtonRect(Transform movementRoot)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			Transform val = FindExistingButton(movementRoot);
			if (!((Object)val != (Object)null))
			{
				return null;
			}
			return ((Component)val).GetComponent<RectTransform>();
		}

		internal static RectTransform TryGetMovementValueRowRect(Transform movementRoot)
		{
			Transform obj = FindValueRowContainer(movementRoot);
			return (RectTransform)(object)((obj is RectTransform) ? obj : null);
		}

		private static Transform FindExistingButton(Transform root)
		{
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name == "TabsUnlimited_MoveWhileTurningButton")
				{
					return val;
				}
			}
			return null;
		}

		private static void ClearDestroyedButtonRefs()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if (!((Object)_toggleButton != (Object)null))
			{
				_toggleLabel = null;
			}
		}

		private static void StopLayoutCoroutine()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			if (_layoutCoroutine != null && !((Object)Plugin.Instance == (Object)null))
			{
				((MonoBehaviour)Plugin.Instance).StopCoroutine(_layoutCoroutine);
				_layoutCoroutine = null;
			}
		}

		private static void ToggleMoveWhileTurning()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			_moveWhileTurning = !_moveWhileTurning;
			_explicitlySet = true;
			RefreshButtonUi();
			if (TryGetEditorSpawnBlueprint(out var manager, out var blueprint))
			{
				MoveWhileTurningHelper.SetExplicit(blueprint, _moveWhileTurning);
				object obj = EditorLoadedUnitField?.GetValue(manager);
				UnitBlueprint val = (UnitBlueprint)((obj is UnitBlueprint) ? obj : null);
				if ((Object)(object)val != (Object)null && (Object)val != (Object)null)
				{
					MoveWhileTurningHelper.SetExplicit(val, _moveWhileTurning);
				}
			}
			SyncLiveUnit(Object.FindObjectOfType<UnitEditorManager>());
		}

		private static void RefreshButtonUi()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			if (!((Object)_toggleLabel == (Object)null))
			{
				_toggleLabel.text = (_moveWhileTurning ? "Turning: ON" : "Turning: OFF");
			}
		}

		private static void SyncLiveUnit(UnitEditorManager manager)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			if (!((Object)manager == (Object)null) && EditorSpawnedBaseField?.GetValue(manager) is GameObject[] array && array != null && array.Length != 0 && !((Object)array[0] == (Object)null))
			{
				MovementHandler componentInChildren = array[0].GetComponentInChildren<MovementHandler>();
				if (!((Object)componentInChildren == (Object)null))
				{
					componentInChildren.stopForTurns = !_moveWhileTurning;
				}
			}
		}

		private static void StripMetadataFromDescriptionField(UnitEditorManager manager)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			UnitEditorUIManager val = manager?.UIManager;
			if (!((Object)val == (Object)null) && !(GetUnitDescriptionMethod == null) && !(SetUnitDescriptionMethod == null))
			{
				string obj = (GetUnitDescriptionMethod.Invoke(val, null) as string) ?? string.Empty;
				string text = MoveWhileTurningMetadata.Strip(obj);
				if (!string.Equals(obj, text, StringComparison.Ordinal))
				{
					SetUnitDescriptionMethod.Invoke(val, new object[1] { text });
				}
				object obj2 = EditorLoadedUnitField?.GetValue(manager);
				UnitBlueprint val2 = (UnitBlueprint)((obj2 is UnitBlueprint) ? obj2 : null);
				if ((Object)(object)val2 != (Object)null && (Object)val2 != (Object)null)
				{
					val2.UnitDescription = MoveWhileTurningMetadata.Strip(val2.UnitDescription);
				}
			}
		}

		private static bool IsCurrentMovementNeverStop(UnitEditorManager manager)
		{
			if (!(MovementTypesComponentsField?.GetValue(manager) is List<IMovementComponent> list))
			{
				return false;
			}
			if (!(CurrentMovementTypeField?.GetValue(manager) is int num) || num < 0 || num >= list.Count)
			{
				return false;
			}
			return list[num] is NeverStopRunning;
		}

		private static bool TryGetEditorSpawnBlueprint(out UnitEditorManager manager, out UnitBlueprint blueprint)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			manager = Object.FindObjectOfType<UnitEditorManager>();
			blueprint = null;
			if ((Object)manager == (Object)null)
			{
				return false;
			}
			if (!(EditorUnitBasesField?.GetValue(manager) is UnitBaseWrapper[] array) || !(EditorCurrentUnitBaseField?.GetValue(manager) is int num) || num < 0 || num >= array.Length)
			{
				return false;
			}
			blueprint = array[num].UnitBaseBlueprint;
			return (Object)blueprint != (Object)null;
		}

		private static void CleanupLegacyRows(UnitEditorBasePageUI basePage)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			object obj = ContentParentField?.GetValue(basePage);
			Transform val = (Transform)((obj is Transform) ? obj : null);
			if ((Object)(object)val != (Object)null)
			{
				Transform[] componentsInChildren = ((Component)val).GetComponentsInChildren<Transform>(true);
				foreach (Transform val2 in componentsInChildren)
				{
					if (((Object)val2).name == "TabsUnlimited_MoveWhileTurningRow")
					{
						Object.Destroy((Object)((Component)val2).gameObject);
					}
				}
			}
			object obj2 = MovementTypeField?.GetValue(basePage);
			UnitEditorSelectableItem val3 = (UnitEditorSelectableItem)((obj2 is UnitEditorSelectableItem) ? obj2 : null);
			if ((Object)(object)val3 != (Object)null)
			{
				Transform parent = ((Component)val3).transform.parent;
				Transform val4 = (((Object)(object)parent != (Object)null) ? parent.Find("TabsUnlimited_MoveWhileTurningRow") : null);
				if ((Object)val4 != (Object)null)
				{
					Object.Destroy((Object)((Component)val4).gameObject);
				}
			}
		}

		private static void CleanupButton(UnitEditorBasePageUI basePage)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			StopLayoutCoroutine();
			CleanupLegacyRows(basePage);
			object obj = MovementTypeField?.GetValue(basePage);
			UnitEditorSelectableItem val = (UnitEditorSelectableItem)((obj is UnitEditorSelectableItem) ? obj : null);
			if ((Object)(object)val != (Object)null)
			{
				Transform[] componentsInChildren = ((Component)val).GetComponentsInChildren<Transform>(true);
				foreach (Transform val2 in componentsInChildren)
				{
					if (((Object)val2).name == "TabsUnlimited_MoveWhileTurningButton")
					{
						Object.Destroy((Object)((Component)val2).gameObject);
					}
				}
			}
			_toggleButton = null;
			_toggleLabel = null;
			UnitEditorBasePageScroll.Cleanup(basePage, fullRollback: true);
		}
	}
	internal static class WinConditionsConfig
	{
		internal static bool Enabled = true;

		internal static void Bind(ConfigFile config)
		{
			Enabled = config.Bind<bool>("WinConditions", "Enabled", true, "Enable custom win conditions (Kill All Selected Units, Kill Enemy Count).").Value;
		}
	}
}
namespace TabsUnlimited.WinConditions
{
	internal static class KillEnemyCountEditorUi
	{
		private static readonly FieldInfo FieldControllerField = AccessTools.Field(typeof(InspectorPanel), "m_fieldController");

		private static readonly FieldInfo BoundGuidField = AccessTools.Field(typeof(InspectorPanel), "m_boundGuid");

		private static readonly FieldInfo WinConditionEntriesField = AccessTools.Field(typeof(InspectorPanel), "m_winConditionEntries");

		private static readonly FieldInfo ConditionSliderField = AccessTools.Field(typeof(InspectorPanel), "m_conditionValueSlider");

		private static readonly MethodInfo PlayContentAnimatorInMethod = AccessTools.Method(typeof(InspectorPanel), "PlayContentAnimatorIn", (Type[])null, (Type[])null);

		private static int _lastEnsureFrame = -1;

		private static InspectorPanel _lastEnsurePanel;

		internal static bool IsKillEnemyCount(InspectorPanel panel)
		{
			return WinConditionEditorUi.GetInspectedCondition(panel) is KillEnemyCountWinCondition;
		}

		internal static void EnsureInspector(InspectorPanel panel)
		{
			if ((Object)(object)panel == (Object)null || !IsKillEnemyCount(panel) || (Time.frameCount == _lastEnsureFrame && (Object)(object)_lastEnsurePanel == (Object)(object)panel))
			{
				return;
			}
			_lastEnsureFrame = Time.frameCount;
			_lastEnsurePanel = panel;
			WinConditionEditorUi.EndMultiKillPickSession();
			object? obj = FieldControllerField?.GetValue(panel);
			FieldController val = (FieldController)((obj is FieldController) ? obj : null);
			if (val != null)
			{
				val.TurnOffEditButton();
				if (WinConditionEditorUi.GetInspectedCondition(panel) is KillEnemyCountWinCondition condition)
				{
					KillEnemyCountFieldUi.ConfigureFieldController(val, condition);
				}
			}
			if (((BoundGuidField?.GetValue(panel) is Guid guid) ? guid : Guid.Empty) == Guid.Empty)
			{
				WinConditionEditorUi.PrepareAddFromBrowserIfNeeded(panel);
				WinConditionEditorUi.ShowAddButtonForPanel(panel);
			}
			else
			{
				WinConditionEditorUi.ShowApplyAndDeleteForPanel(panel);
			}
			panel.UpdateAddButton();
			PlayContentAnimatorInMethod?.Invoke(panel, null);
		}

		internal static bool ShouldBlockTypeCarouselChange(InspectorPanel panel, int newIndex)
		{
			if ((Object)(object)panel == (Object)null || !(WinConditionEntriesField?.GetValue(panel) is IList list))
			{
				return false;
			}
			if (((BoundGuidField?.GetValue(panel) is Guid guid) ? guid : Guid.Empty) == Guid.Empty)
			{
				return false;
			}
			WinCondition inspectedCondition = WinConditionEditorUi.GetInspectedCondition(panel);
			if (!(inspectedCondition is KillEnemyCountWinCondition) && !(inspectedCondition is MustKillAllSelectedUnitsWinCondition))
			{
				return false;
			}
			if (newIndex < 0 || newIndex >= list.Count)
			{
				return false;
			}
			string text = list[newIndex] as string;
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			return !string.Equals(text, ((object)inspectedCondition).GetType().Name, StringComparison.Ordinal);
		}

		internal static void RestoreSliderToInspectedType(InspectorPanel panel)
		{
			if ((Object)(object)panel == (Object)null || ConditionSliderField?.GetValue(panel) == null || !(WinConditionEntriesField?.GetValue(panel) is IList list))
			{
				return;
			}
			WinCondition inspectedCondition = WinConditionEditorUi.GetInspectedCondition(panel);
			if (inspectedCondition == null)
			{
				return;
			}
			string name = ((object)inspectedCondition).GetType().Name;
			for (int i = 0; i < list.Count; i++)
			{
				if (string.Equals(list[i] as string, name, StringComparison.Ordinal))
				{
					object value = ConditionSliderField.GetValue(panel);
					value.GetType().GetMethod("SetValueIndex", new Type[2]
					{
						typeof(int),
						typeof(bool)
					})?.Invoke(value, new object[2] { i, false });
					break;
				}
			}
		}
	}
	internal static class KillEnemyCountFieldUi
	{
		private const string KillCountLabel = "Kill this many enemy units";

		private static readonly Type SurviveForTimeType = AccessTools.TypeByName("WinConditionsSurviveForTime");

		private static readonly PropertyInfo PropertyOwnerProperty = AccessTools.Property(typeof(UIPropertyField), "PropertyOwner");

		internal static void ConfigureFieldController(FieldController fieldController, KillEnemyCountWinCondition condition)
		{
			if (!((Object)(object)fieldController == (Object)null) && condition != null)
			{
				HideSurviveTimeChrome(((Component)fieldController).transform);
				StyleKillCountFields(fieldController, condition);
				((object)fieldController).GetType().GetMethod("UpdateContentHeight")?.Invoke(fieldController, null);
			}
		}

		private static void HideSurviveTimeChrome(Transform fieldControllerRoot)
		{
			if (SurviveForTimeType == null || (Object)(object)fieldControllerRoot == (Object)null)
			{
				return;
			}
			Component[] componentsInChildren = ((Component)fieldControllerRoot).GetComponentsInChildren(SurviveForTimeType, true);
			foreach (Component obj in componentsInChildren)
			{
				MonoBehaviour val = (MonoBehaviour)(object)((obj is MonoBehaviour) ? obj : null);
				if (val != null)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
		}

		private static void StyleKillCountFields(FieldController fieldController, KillEnemyCountWinCondition condition)
		{
			UIPropertyField[] componentsInChildren = ((Component)fieldController).GetComponentsInChildren<UIPropertyField>(true);
			foreach (UIPropertyField val in componentsInChildren)
			{
				if (PropertyOwnerProperty?.GetValue(val, null) == condition)
				{
					WinConditionFieldLabels.Force(val, "Kill this many enemy units");
					object obj = AccessTools.Field(typeof(UIPropertyField), "m_inputField")?.GetValue(val);
					obj?.GetType().GetProperty("text")?.SetValue(obj, condition.RequiredKills.ToString(), null);
				}
			}
		}
	}
	[WinConditionID("Kill Enemy Count", true)]
	public class KillEnemyCountWinCondition : WinCondition
	{
		private const int DefaultRequiredKills = 3;

		private const int MinRequiredKills = 1;

		private const int MaxRequiredKills = 999;

		[Title("Kill this many enemy units")]
		[SerializeField]
		[JsonProperty]
		private int m_requiredKills = 3;

		[JsonIgnore]
		private int _killsThisBattle;

		[JsonIgnore]
		private readonly HashSet<Guid> _countedDeathGuids = new HashSet<Guid>();

		[JsonIgnore]
		private bool _winDeclared;

		public int RequiredKills
		{
			get
			{
				return Mathf.Clamp(m_requiredKills, 1, 999);
			}
			set
			{
				m_requiredKills = Mathf.Clamp(value, 1, 999);
			}
		}

		public int KillsThisBattle => _killsThisBattle;

		public override string GetDescription(out string[] args)
		{
			args = null;
			return "Kill a set number of units on the enemy team. Any enemy unit counts toward the total.";
		}

		public override string GetDescriptionForListItem(out string[] args)
		{
			args = null;
			return $"Kill {RequiredKills} enemy units";
		}

		public override string GetBattleDescription(bool invertDescription)
		{
			//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_0017: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			Team enemyTeam = GetEnemyTeam();
			string text = RequiredKills.ToString();
			string teamText = ((WinCondition)this).GetTeamText(enemyTeam);
			if (invertDescription)
			{
				string singlePhrase = Localizer.GetSinglePhrase("LABEL_PROTECT", Array.Empty<string>());
				return ((WinCondition)this).GetWhiteColor() + singlePhrase + " " + ((WinCondition)this).GetColoredText(enemyTeam) + teamText + " — lose fewer than " + text + " units";
			}
			return ((WinCondition)this).GetWhiteColor() + "Kill " + ((WinCondition)this).GetColoredText(enemyTeam) + teamText + " units (" + text + " kills)";
		}

		public override string GetWinDescription()
		{
			//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_003a: 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)
			Team enemyTeam = GetEnemyTeam();
			return ((WinCondition)this).GetWhiteColor() + "Killed " + RequiredKills + " " + ((WinCondition)this).GetColoredText(enemyTeam) + ((WinCondition)this).GetTeamText(enemyTeam) + " units";
		}

		public override ReferenceRequest<Unit> GetUnitToKill()
		{
			return null;
		}

		public override void OnUnitDied(Unit unit)
		{
			TryRegisterKill(unit);
		}

		public override void OnUpdate()
		{
		}

		public override void OnRemovedFromgGUI()
		{
			((WinCondition)this).Reset();
		}

		public override void Reset()
		{
			_killsThisBattle = 0;
			_countedDeathGuids.Clear();
			_winDeclared = false;
		}

		private Team GetEnemyTeam()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((WinCondition)this).OwningTeam == 0)
			{
				return (Team)1;
			}
			return (Team)0;
		}

		private bool TryRegisterKill(Unit unit)
		{
			//IL_001c: 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)
			if (_winDeclared || (Object)(object)unit == (Object)null || unit.RuntimeReference == null)
			{
				return false;
			}
			if (unit.Team != GetEnemyTeam())
			{
				return false;
			}
			Guid guid = ((RuntimeReference)unit.RuntimeReference).Guid;
			if (!_countedDeathGuids.Add(guid))
			{
				return false;
			}
			_killsThisBattle++;
			string arg = (((Object)(object)unit.unitBlueprint != (Object)null) ? Localizer.GetSinglePhrase(unit.unitBlueprint.Name, Array.Empty<string>()) : "enemy");
			Plugin.LogInfo($"Kill-enemy-count: {_killsThisBattle}/{RequiredKills} ({arg})");
			TryDeclareWin();
			return true;
		}

		private void TryDeclareWin()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (!_winDeclared && _killsThisBattle >= RequiredKills && (((WinCondition)this).GameMode == null || !((WinCondition)this).GameMode.MatchOver))
			{
				_winDeclared = true;
				Plugin.LogInfo("Kill-enemy-count: required kills reached — ending battle.");
				((WinCondition)this).GameMode.DecideWinner(((WinCondition)this).OwningTeam, ((WinCondition)this).GetWinDescription());
			}
		}
	}
	internal static class MultiKillInspectorChrome
	{
		[CompilerGenerated]
		private sealed class <ApplyDeferredRoutine>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public InspectorPanel panel;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ApplyDeferredRoutine>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
				{
					<>1__state = -1;
					if ((Object)(object)panel == (Object)null || GetMultiKill(panel) == null)
					{
						return false;
					}
					object winConditionsComponent = WinConditionEditorUi.GetWinConditionsComponent(panel);
					Apply(panel, winConditionsComponent);
					_chromeAppliedPanel = panel;
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static InspectorPanel _chromeAppliedPanel;

		public static void Apply(InspectorPanel panel, object winConditions)
		{
			if (!((Object)(object)panel == (Object)null) && GetMultiKill(panel) != null && winConditions != null && Traverse.Create(winConditions).Property("VictoryConditionsPanelIsOpen", (object[])null).GetValue<bool>() && !WinConditionEditorUi.IsMultiKillPickSessionActive)
			{
				HideExtraBackButtons(panel);
			}
		}

		public static void ApplyDeferred(InspectorPanel panel)
		{
			if (!((Object)(object)panel == (Object)null) && GetMultiKill(panel) != null && !((Object)(object)_chromeAppliedPanel == (Object)(object)panel))
			{
				((MonoBehaviour)panel).StartCoroutine(ApplyDeferredRoutine(panel));
			}
		}

		internal static void ResetForPanel(InspectorPanel panel)
		{
			if ((Object)(object)_chromeAppliedPanel == (Object)(object)panel)
			{
				_chromeAppliedPanel = null;
			}
		}

		[IteratorStateMachine(typeof(<ApplyDeferredRoutine>d__4))]
		private static IEnumerator ApplyDeferredRoutine(InspectorPanel panel)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyDeferredRoutine>d__4(0)
			{
				panel = panel
			};
		}

		private static MustKillAllSelectedUnitsWinCondition GetMultiKill(InspectorPanel panel)
		{
			return WinConditionEditorUi.GetMultiKill(panel);
		}

		private static void HideExtraBackButtons(InspectorPanel panel)
		{
			List<RectTransform> list = new List<RectTransform>();
			Button[] componentsInChildren = ((Component)panel).GetComponentsInChildren<Button>(true);
			foreach (Button val in componentsInChildren)
			{
				if (LooksLikeBackButton(val))
				{
					RectTransform component = ((Component)val).GetComponent<RectTransform>();
					if ((Object)(object)component != (Object)null)
					{
						list.Add(component);
					}
				}
			}
			if (list.Count > 1)
			{
				list.Sort((RectTransform a, RectTransform b) => ((Transform)a).position.x.CompareTo(((Transform)b).position.x));
				for (int j = 1; j < list.Count; j++)
				{
					((Component)list[j]).gameObject.SetActive(false);
				}
			}
		}

		private static bool LooksLikeBackButton(Button button)
		{
			Component[] componentsInChildren = ((Component)button).GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				PropertyInfo property = ((object)val).GetType().GetProperty("text");
				if (!(property == null) && !(property.PropertyType != typeof(string)))
				{
					string text = property.GetValue(val, null) as string;
					if (!string.IsNullOrEmpty(text) && text.IndexOf("BACK", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return true;
					}
				}
			}
			return false;
		}
	}
	internal static class MultiKillTargetFieldUi
	{
		private const int MaxVisibleIcons = 8;

		private const float IconSize = 44f;

		private const float IconSpacing = 6f;

		private const float FramePadding = 16f;

		private const string IconRowName = "StayCombatFix_MultiKillIconRow";

		private static readonly PropertyInfo PropertyOwnerProperty = AccessTools.Property(typeof(UIPropertyField), "PropertyOwner");

		private static readonly FieldInfo ReferenceLabelField = AccessTools.Field(typeof(UIReferenceField), "m_referenceLabel");

		private static readonly FieldInfo UnitIconField = AccessTools.Field(typeof(UIReferenceField), "m_UnitIcon");

		private static readonly FieldInfo InspectorFieldControllerField = AccessTools.Field(typeof(InspectorPanel), "m_fieldController");

		public static bool IsMultiKillField(UIReferenceField field)
		{
			return PropertyOwnerProperty.GetValue(field, null) is MustKillAllSelectedUnitsWinCondition;
		}

		public static void Refresh(UIReferenceField field, MustKillAllSelectedUnitsWinCondition condition)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)field == (Object)null || condition == null)
			{
				return;
			}
			object? obj = ReferenceLabelField?.GetValue(field);
			LocalizeText val = (LocalizeText)((obj is LocalizeText) ? obj : null);
			object? obj2 = UnitIconField?.GetValue(field);
			Image val2 = (Image)((obj2 is Image) ? obj2 : null);
			Transform val3 = ((Component)field).transform.Find("ValueArea");
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = ((Component)field).transform;
			}
			ClearAllIconRows(((Component)field).transform);
			RectTransform val4 = FindIconFrame(val3, val2);
			if ((Object)(object)val4 == (Object)null)
			{
				return;
			}
			if (condition.TargetCount == 0)
			{
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(true);
					val.LocaleID = "LABEL_EMPTY";
				}
				if ((Object)(object)val2 != (Object)null)
				{
					((Behaviour)val2).enabled = true;
					val2.sprite = null;
					((Component)val2).gameObject.SetActive(true);
				}
				val4.sizeDelta = new Vector2(60f, 60f);
				return;
			}
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.SetActive(false);
			}
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).gameObject.SetActive(true);
				((Behaviour)val2).enabled = false;
				val2.sprite = null;
			}
			Transform orCreateIconRow = GetOrCreateIconRow((Transform)(object)val4);
			RuntimeReferenceService service = ServiceLocator.GetService<RuntimeReferenceService>();
			List<Unit> list = new List<Unit>();
			HashSet<Guid> hashSet = new HashSet<Guid>();
			foreach (ReferenceRequest<Unit> target in condition.Targets)
			{
				if (target != null && list.Count < 8 && hashSet.Add(((RuntimeReference)target).Guid))
				{
					Unit referenceTarget = service.GetReferenceTarget<Unit>((RuntimeReference)(object)target);
					if (!((Object)(object)referenceTarget?.unitBlueprint == (Object)null))
					{
						list.Add(referenceTarget);
					}
				}
			}
			HideStaticFrameImages(val4, orCreateIconRow);
			for (int i = 0; i < list.Count; i++)
			{
				CreateIcon(orCreateIconRow, list[i], i, list.Count);
			}
			LayoutIconFrame(val4, list.Count);
		}

		public static void RefreshAllFields(MustKillAllSelectedUnitsWinCondition condition, InspectorPanel panel = null)
		{
			if (condition == null)
			{
				return;
			}
			UIReferenceField[] componentsInChildren;
			if ((Object)(object)panel != (Object)null)
			{
				object? obj = InspectorFieldControllerField?.GetValue(panel);
				FieldController val = (FieldController)((obj is FieldController) ? obj : null);
				if (val != null)
				{
					componentsInChildren = ((Component)val).GetComponentsInChildren<UIReferenceField>(true);
					foreach (UIReferenceField val2 in componentsInChildren)
					{
						if (PropertyOwnerProperty.GetValue(val2, null) == condition)
						{
							Refresh(val2, condition);
						}
					}
					return;
				}
			}
			componentsInChildren = Object.FindObjectsOfType<UIReferenceField>();
			foreach (UIReferenceField val3 in componentsInChildren)
			{
				if (PropertyOwnerProperty.GetValue(val3, null) == condition)
				{
					Refresh(val3, condition);
				}
			}
		}

		private static Transform GetOrCreateIconRow(Transform parent)
		{
			//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_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_0067: 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_0087: 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)
			Transform val = parent.Find("StayCombatFix_MultiKillIconRow");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			GameObject val2 = new GameObject("StayCombatFix_MultiKillIconRow", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(parent, false);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = Vector2.zero;
			component.sizeDelta = Vector2.zero;
			return val2.transform;
		}

		private static void ClearAllIconRows(Transform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return;
			}
			Transform[] array = (from t in ((Component)root).GetComponentsInChildren<Transform>(true)
				where ((Object)t).name == "StayCombatFix_MultiKillIconRow"
				select t).ToArray();
			foreach (Transform val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)((Component)val).gameObject);
				}
			}
		}

		private static void HideStaticFrameImages(RectTransform iconFrame, Transform iconRow)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if ((Object)(object)iconFrame == (Object)null)
			{
				return;
			}
			foreach (Transform item in (Transform)iconFrame)
			{
				Transform val = item;
				if (!((Object)(object)val == (Object)(object)iconRow) && !(((Object)val).name == "StayCombatFix_MultiKillIconRow") && (Object)(object)((Component)val).GetComponent<Image>() != (Object)null)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
		}

		private static void CreateIcon(Transform row, Unit unit, int index, int totalCount)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005a: 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_0084: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject($"Icon_{index}", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(row, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = new Vector2(44f, 44f);
			float num = (0f - ((float)totalCount * 44f + (float)Mathf.Max(0, totalCount - 1) * 6f)) * 0.5f + 22f;
			component.anchoredPosition = new Vector2(num + (float)index * 50f, 0f);
			Image image = val.GetComponent<Image>();
			image.preserveAspect = true;
			((Graphic)image).raycastTarget = false;
			unit.unitBlueprint.Entity.GetSpriteIconAsync((Action<Sprite>)delegate(Sprite sprite)
			{
				if ((Object)(object)sprite != (Object)null && (Object)(object)image != (Object)null)
				{
					image.sprite = sprite;
				}
			});
		}

		private static RectTransform FindIconFrame(Transform valueArea, Image mainIcon)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			if ((Object)(object)valueArea == (Object)null)
			{
				if (mainIcon == null)
				{
					return null;
				}
				return ((Component)mainIcon).GetComponent<RectTransform>();
			}
			if ((Object)(object)mainIcon != (Object)null)
			{
				Transform parent = ((Component)mainIcon).transform.parent;
				if ((Object)(object)parent != (Object)null && (Object)(object)parent != (Object)(object)valueArea)
				{
					foreach (Transform item in parent)
					{
						Transform val = item;
						if (!((Object)(object)val == (Object)(object)((Component)mainIcon).transform) && (Object)(object)((Component)val).GetComponent<Image>() != (Object)null)
						{
							return (RectTransform)(object)((val is RectTransform) ? val : null);
						}
					}
					return (RectTransform)(object)((parent is RectTransform) ? parent : null);
				}
			}
			foreach (Transform item2 in valueArea)
			{
				Transform val2 = item2;
				if (((Object)val2).name.IndexOf("Icon", StringComparison.OrdinalIgnoreCase) >= 0 && (Object)(object)((Component)val2).GetComponent<Image>() != (Object)null)
				{
					return (RectTransform)(object)((val2 is RectTransform) ? val2 : null);
				}
			}
			return (RectTransform)(object)((valueArea is RectTransform) ? valueArea : null);
		}

		private static void LayoutIconFrame(RectTransform iconFrame, int iconCount)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)iconFrame == (Object)null) && iconCount > 0)
			{
				float num = (float)iconCount * 44f + (float)Mathf.Max(0, iconCount - 1) * 6f;
				float num2 = 44f;
				iconFrame.sizeDelta = new Vector2(num + 16f, num2 + 16f);
			}
		}
	}
	internal static class MultiKillTargetIcons
	{
		private static MethodInfo _setIconMethod;

		private static FieldInfo _iconedUnitsField;

		private static FieldInfo _iconInstancesField;

		public static void EnsureIcon(ReferenceRenderer renderer, ReferenceRequest<Unit> target)
		{
			if ((Object)(object)renderer == (Object)null || target == null)
			{
				return;
			}
			EnsureReflection();
			if (!(_setIconMethod == null))
			{
				RegisterIconedUnit(renderer, target);
				Unit referenceTarget = ServiceLocator.GetService<RuntimeReferenceService>().GetReferenceTarget<Unit>((RuntimeReference)(object)target);
				if ((Object)(object)referenceTarget != (Object)null && ((Object)(object)referenceTarget.data == (Object)null || !referenceTarget.data.Dead))
				{
					SetIconIfMissing(renderer, referenceTarget);
				}
			}
		}

		public static void SafeRemoveIcon(ReferenceRenderer renderer, ReferenceRequest<Unit> target)
		{
			if ((Object)(object)renderer == (Object)null || target == null)
			{
				return;
			}
			EnsureReflection();
			Unit referenceTarget = ServiceLocator.GetService<RuntimeReferenceService>().GetReferenceTarget<Unit>((RuntimeReference)(object)target);
			if ((Object)(object)referenceTarget != (Object)null)
			{
				referenceTarget.RemoveHighlight();
				WinConTargetUI componentInChildren = ((Component)referenceTarget).GetComponentInChildren<WinConTargetUI>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					if (_iconInstancesField?.GetValue(renderer) is List<GameObject> list)
					{
						list.Remove(((Component)componentInChildren).gameObject);
					}
					Object.Destroy((Object)(object)((Component)componentInChildren).gameObject);
				}
			}
			UnregisterIconedUnit(renderer, ((RuntimeReference)target).Guid);
		}

		public static void RefreshCondition(ReferenceRenderer renderer, MustKillAllSelectedUnitsWinCondition condition)
		{
			if ((Object)(object)renderer == (Object)null || condition == null)
			{
				return;
			}
			EnsureReflection();
			if (_setIconMethod == null)
			{
				return;
			}
			RuntimeReferenceService service = ServiceLocator.GetService<RuntimeReferenceService>();
			foreach (ReferenceRequest<Unit> target in condition.Targets)
			{
				if (target != null)
				{
					RegisterIconedUnit(renderer, target);
					Unit referenceTarget = service.GetReferenceTarget<Unit>((RuntimeReference)(object)target);
					if (!((Object)(object)referenceTarget == (Object)null) && (!((Object)(object)referenceTarget.data != (Object)null) || !referenceTarget.data.Dead))
					{
						SetIconIfMissing(renderer, referenceTarget);
					}
				}
			}
		}

		private static void RegisterIconedUnit(ReferenceRenderer renderer, ReferenceRequest<Unit> target)
		{
			if (!IsInIconedUnits(renderer, ((RuntimeReference)target).Guid) && _iconedUnitsField?.GetValue(renderer) is List<RuntimeReference> list)
			{
				list.Add((RuntimeReference)(object)target);
			}
		}

		private static void UnregisterIconedUnit(ReferenceRenderer renderer, Guid guid)
		{
			if (!(_iconedUnitsField?.GetValue(renderer) is List<RuntimeReference> list))
			{
				return;
			}
			for (int num = list.Count - 1; num >= 0; num--)
			{
				if (list[num] != null && list[num].Guid == guid)
				{
					list.RemoveAt(num);
				}
			}
		}

		private static bool IsInIconedUnits(ReferenceRenderer renderer, Guid guid)
		{
			if (!(_iconedUnitsField?.GetValue(renderer) is List<RuntimeReference> list))
			{
				return false;
			}
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i] != null && list[i].Guid == guid)
				{
					return true;
				}
			}
			return false;
		}

		private static void SetIconIfMissing(ReferenceRenderer renderer, Unit unit)
		{
			if (!((Object)(object)unit == (Object)null) && !((Object)(object)((Component)unit).GetComponentInChildren<WinConTargetUI>(true) != (Object)null))
			{
				_setIconMethod.Invoke(renderer, new object[1] { unit });
			}
		}

		private static void EnsureReflection()
		{
			if (!(_setIconMethod != null))
			{
				Type typeFromHandle = typeof(ReferenceRenderer);
				_setIconMethod = AccessTools.Method(typeFromHandle, "SetIcon", new Type[1] { typeof(Unit) }, (Type[])null);
				_iconedUnitsField = AccessTools.Field(typeFromHandle, "m_iconedUnits");
				_iconInstancesField = AccessTools.Field(typeFromHandle, "m_iconInstances");
			}
		}
	}
	internal static class MultiKillTargetRegistry
	{
		private static readonly HashSet<Guid> TargetGuids = new HashSet<Guid>();

		public static bool HasTargets => TargetGuids.Count > 0;

		public static bool IsTarget(Guid unitGuid)
		{
			return TargetGuids.Contains(unitGuid);
		}

		public static void Clear()
		{
			TargetGuids.Clear();
		}

		public static void Rebuild(WinConditionPropagator propagator)
		{
			TargetGuids.Clear();
			if (propagator != null)
			{
				AddFromPropagator(propagator);
			}
		}

		public static void AddFromCondition(MustKillAllSelectedUnitsWinCondition condition)
		{
			if (condition?.Targets == null)
			{
				return;
			}
			foreach (ReferenceRequest<Unit> target in condition.Targets)
			{
				if (target != null)
				{
					TargetGuids.Add(((RuntimeReference)target).Guid);
				}
			}
		}

		public static void RemoveGuid(Guid unitGuid)
		{
			TargetGuids.Remove(unitGuid);
		}

		public static void AddGuid(Guid unitGuid)
		{
			TargetGuids.Add(unitGuid);
		}

		private static void AddFromPropagator(WinConditionPropagator propagator)
		{
			//IL_0012: 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)
			Team[] array = (Team[])(object)new Team[2]
			{
				default(Team),
				(Team)1
			};
			foreach (Team val in array)
			{
				WinCondition[] winConditionsForTeam = propagator.GetWinConditionsForTeam(val);
				for (int j = 0; j < winConditionsForTeam.Length; j++)
				{
					if (winConditionsForTeam[j] is MustKillAllSelectedUnitsWinCondition condition)
					{
						AddFromCondition(condition);
					}
				}
			}
		}
	}
	[WinConditionID("Kill All Selected Units", false)]
	public class MustKillAllSelectedUnitsWinCondition : WinCondition
	{
		private const int MaxNamesInSummary = 3;

		private const string ListItemLocaleId = "WIN_CON_DEFEAT_UNIT_DESC_LIST";

		[Title("Targets")]
		[LockReferenceToTeam(/*Could not decode attribute arguments.*/)]
		[SerializeField]
		[JsonProperty]
		private ReferenceRequest<Unit> m_addTargetPicker;

		[JsonProperty]
		private List<ReferenceRequest<Unit>> m_targets = new List<ReferenceRequest<Unit>>();

		[JsonIgnore]
		private readonly HashSet<Guid> _eliminatedTargetGuids = new HashSet<Guid>();

		[JsonIgnore]
		private bool _winDeclared;

		public int TargetCount => m_targets?.Count ?? 0;

		public IReadOnlyList<ReferenceRequest<Unit>> Targets => m_targets;

		public void AddTarget(ReferenceRequest<Unit> request)
		{
			if (request != null)
			{
				if (m_targets.Any((ReferenceRequest<Unit> t) => t != null && ((RuntimeReference)t).Guid == ((RuntimeReference)request).Guid))
				{
					request.Release();
					return;
				}
				m_targets.Add(request);
				MultiKillTargetRegistry.AddGuid(((RuntimeReference)request).Guid);
			}
		}

		public bool ContainsTarget(Guid unitGuid)
		{
			return m_targets.Any((ReferenceRequest<Unit> t) => t != null && ((RuntimeReference)t).Guid == unitGuid);
		}

		public bool RemoveTarget(Guid unitGuid)
		{
			if (m_targets == null)
			{
				return false;
			}
			ReferenceRequest<Unit> val = null;
			for (int num = m_targets.Count - 1; num >= 0; num--)
			{
				if (m_targets[num] != null && !(((RuntimeReference)m_targets[num]).Guid != unitGuid))
				{
					val = m_targets[num];
					m_targets.RemoveAt(num);
					break;
				}
			}
			if (val == null)
			{
				return false;
			}
			_eliminatedTargetGuids.Remove(unitGuid);
			MultiKillTargetRegistry.RemoveGuid(unitGuid);
			MultiKillTargetIcons.SafeRemoveIcon(WinConditionUiPatches.GetReferenceRenderer(), val);
			val.Release();
			return true;
		}

		public void RestoreTargetIcons()
		{
			ReferenceRenderer referenceRenderer = WinConditionUiPatches.GetReferenceRenderer();
			if ((Object)(object)referenceRenderer != (Object)null)
			{
				MultiKillTargetIcons.RefreshCondition(referenceRenderer, this);
			}
		}

		public override string GetDescription(out string[] args)
		{
			args = null;
			if (TargetCount == 0)
			{
				return "Pick enemy units on the map. Every picked unit must be killed to win.";
			}
			return $"Kill all {TargetCount} picked units. Click the map to add or remove targets.";
		}

		public override string GetBattleDescription(bool invertDescription)
		{
			//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_008c: 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)
			string text = FormatCompactNameList();
			if (string.IsNullOrEmpty(text))
			{
				return string.Empty;
			}
			Team enemyTeam = GetEnemyTeam();
			string singlePhrase = Localizer.GetSinglePhrase("LABEL_DEFEAT", Array.Empty<string>());
			string singlePhrase2 = Localizer.GetSinglePhrase("LABEL_PROTECT", Array.Empty<string>());
			if (invertDescription)
			{
				return ((WinCondition)this).GetWhiteColor() + singlePhrase2 + " " + ((WinCondition)this).GetColoredText(enemyTeam) + text;
			}
			return ((WinCondition)this).GetWhiteColor() + singlePhrase + " " + ((WinCondition)this).GetColoredText(enemyTeam) + text;
		}

		public override string GetDescriptionForListItem(out string[] args)
		{
			string text = FormatCompactNameList();
			if (string.IsNullOrEmpty(text))
			{
				args = null;
				return "No targets selected";
			}
			args = new string[1] { text };
			return "WIN_CON_DEFEAT_UNIT_DESC_LIST";
		}

		public override string GetWinDescription()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			string text = FormatCompactNameList();
			if (string.IsNullOrEmpty(text))
			{
				return string.Empty;
			}
			return ((WinCondition)this).GetWhiteColor() + "Defeated " + ((WinCondition)this).GetColoredText(GetEnemyTeam()) + text;
		}

		public override ReferenceRequest<Unit> GetUnitToKill()
		{
			if (m_targets.Count <= 0)
			{
				return null;
			}
			return m_targets[0];
		}

		public override void OnUnitDied(Unit unit)
		{
			if (m_targets != null && m_targets.Count != 0 && ((unit != null) ? unit.RuntimeReference : null) != null)
			{
				TryRegisterElimination(((RuntimeReference)unit.RuntimeReference).Guid, unit);
			}
		}

		public override void OnRemovedFromgGUI()
		{
			ReferenceRenderer referenceRenderer = WinConditionUiPatches.GetReferenceRenderer();
			if (m_targets != null)
			{
				foreach (ReferenceRequest<Unit> target in m_targets)
				{
					if (target != null)
					{
						MultiKillTargetIcons.SafeRemoveIcon(referenceRenderer, target);
						target.Release();
					}
				}
				m_targets.Clear();
			}
			if (m_addTargetPicker != null)
			{
				MultiKillTargetIcons.SafeRemoveIcon(referenceRenderer, m_addTargetPicker);
				m_addTargetPicker.Release();
				m_addTargetPicker = null;
			}
			BaseGameMode gameMode = ((WinCondition)this).GameMode;
			MultiKillTargetRegistry.Rebuild((gameMode != null) ? gameMode.WinConditionPropagator : null);
			_eliminatedTargetGuids.Clear();
			_winDeclared = false;
		}

		public override void OnUpdate()
		{
			if (_winDeclared || m_targets == null || CountActiveTargets() == 0)
			{
				return;
			}
			RuntimeReferenceService service = ServiceLocator.GetService<RuntimeReferenceService>();
			foreach (ReferenceRequest<Unit> target in m_targets)
			{
				if (target != null && !_eliminatedTargetGuids.Contains(((RuntimeReference)target).Guid))
				{
					Unit referenceTarget = service.GetReferenceTarget<Unit>((RuntimeReference)(object)target);
					if ((Object)(object)referenceTarget?.data != (Object)null && referenceTarget.data.Dead)
					{
						TryRegisterElimination(((RuntimeReference)target).Guid, referenceTarget);
					}
				}
			}
		}

		public override void Reset()
		{
			_eliminatedTargetGuids.Clear();
			_winDeclared = false;
		}

		public void PrepareForPlacement()
		{
			_eliminatedTargetGuids.Clear();
			_winDeclared = false;
		}

		private Team GetEnemyTeam()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if ((int)((WinCondition)this).OwningTeam == 0)
			{
				return (Team)1;
			}
			return (Team)0;
		}

		private int CountActiveTargets()
		{
			return m_targets?.Count((ReferenceRequest<Unit> t) => t != null) ?? 0;
		}

		private bool TryRegisterElimination(Guid unitGuid, Unit unit)
		{
			if (!ContainsTarget(unitGuid) || !_eliminatedTargetGuids.Add(unitGuid))
			{
				return false;
			}
			RemoveTargetIcon(unitGuid);
			LogTargetEliminated(unit);
			TryDeclareWin();
			return true;
		}

		private void RemoveTargetIcon(Guid unitGuid)
		{
			ReferenceRequest<Unit> val = null;
			if (m_targets != null)
			{
				foreach (ReferenceRequest<Unit> target in m_targets)
				{
					if (target != null && ((RuntimeReference)target).Guid == unitGuid)
					{
						val = target;
						break;
					}
				}
			}
			if (val != null)
			{
				MultiKillTargetIcons.SafeRemoveIcon(WinConditionUiPatches.GetReferenceRenderer(), val);
			}
		}

		private void LogTargetEliminated(Unit unit)
		{
			string arg = (((Object)(object)unit?.unitBlueprint != (Object)null) ? Localizer.GetSinglePhrase(unit.unitBlueprint.Name, Array.Empty<string>()) : "unit");
			Plugin.LogInfo($"Kill-all-targets: eliminated {arg} ({_eliminatedTargetGuids.Count}/{CountActiveTargets()})");
		}

		private void TryDeclareWin()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (!_winDeclared)
			{
				int num = CountActiveTargets();
				if (num != 0 && _eliminatedTargetGuids.Count >= num && (((WinCondition)this).GameMode == null || !((WinCondition)this).GameMode.MatchOver))
				{
					_winDeclared = true;
					Plugin.LogInfo("Kill-all-targets: all selected targets defeated — ending battle.");
					((WinCondition)this).GameMode.DecideWinner(((WinCondition)this).OwningTeam, ((WinCondition)this).GetWinDescription());
				}
			}
		}

		private string FormatCompactNameList()
		{
			List<string> list = CollectTargetDisplayNames();
			if (list.Count == 0)
			{
				return string.Empty;
			}
			if (list.Count <= 3)
			{
				return JoinDisplayNames(list, list.Count);
			}
			List<string> range = list.GetRange(0, 3);
			int num = list.Count - 3;
			return JoinDisplayNames(range, range.Count) + " +" + num + " more";
		}

		private List<string> CollectTargetDisplayNames()
		{
			List<string> list = new List<string>();
			if (m_targets == null)
			{
				return list;
			}
			RuntimeReferenceService service = ServiceLocator.GetService<RuntimeReferenceService>();
			foreach (ReferenceRequest<Unit> target in m_targets)
			{
				if (target != null)
				{
					Unit referenceTarget = service.GetReferenceTarget<Unit>((RuntimeReference)(object)target);
					if (!((Object)(object)referenceTarget?.unitBlueprint == (Object)null))
					{
						list.Add(Localizer.GetSinglePhrase(referenceTarget.unitBlueprint.Name, Array.Empty<string>()));
					}
				}
			}
			return list;
		}

		private static string JoinDisplayNames(List<string> names, int count)
		{
			switch (count)
			{
			case 0:
				return string.Empty;
			case 1:
				return names[0];
			default:
			{
				StringBuilder stringBuilder = new StringBuilder();
				for (int i = 0; i < count; i++)
				{
					if (i > 0)
					{
						stringBuilder.Append((i == count - 1) ? " and " : ", ");
					}
					stringBuilder.Append(names[i]);
				}
				return stringBuilder.ToString();
			}
			}
		}
	}
	internal static class WinConditionDeletion
	{
		private static readonly FieldInfo InspectedConditionField = AccessTools.Field(typeof(InspectorPanel), "m_currentlyInspectedCondition");

		private static readonly FieldInfo CachedConditionField = AccessTools.Field(typeof(InspectorPanel), "m_cachedCondition");

		private static readonly FieldInfo BoundGuidField = AccessTools.Field(typeof(InspectorPanel), "m_boundGuid");

		private static readonly FieldInfo WinConditionPropagatorField = AccessTools.Field(typeof(InspectorPanel), "m_winConditionPropagator");

		private static readonly FieldInfo InspectorTeamField = AccessTools.Field(typeof(InspectorPanel), "m_team");

		internal static bool DeleteFromListItem(InspectorPanel panel, UIListItem listItem, object teamPanel = null)
		{
			//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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)panel == (Object)null || !(((listItem != null) ? listItem.UserData : null) is Guid guid) || guid == Guid.Empty)
			{
				return false;
			}
			object? obj = WinConditionPropagatorField?.GetValue(panel);
			WinConditionPropagator val = (WinConditionPropagator)((obj is WinConditionPropagator) ? obj : null);
			if (val == null || !(InspectorTeamField?.GetValue(panel) is Team val2))
			{
				return false;
			}
			WinCondition winConditionFromTeam = val.GetWinConditionFromTeam(val2, guid);
			if (winConditionFromTeam == null)
			{
				return false;
			}
			RemoveCondition(panel, val, val2, winConditionFromTeam);
			WinConditionEditorUi.RemoveListItem(panel, listItem);
			WinConditionEditorUi.FinishInspectorAfterDelete(panel);
			NotifyTeamPanel(teamPanel);
			return true;
		}

		internal static bool DeleteBoundCondition(InspectorPanel panel, UIListItem listItem, object teamPanel = null)
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)panel == (Object)null)
			{
				return false;
			}
			object? obj = InspectedConditionField?.GetValue(panel);
			WinCondition val = (WinCondition)(((obj is WinCondition) ? obj : null) ?? ((object)/*isinst with value type is only supported in some contexts*/));
			if (val == null && BoundGuidField?.GetValue(panel) is Guid guid && guid != Guid.Empty)
			{
				object? obj2 = WinConditionPropagatorField?.GetValue(panel);
				WinConditionPropagator val2 = (WinConditionPropagator)((obj2 is WinConditionPropagator) ? obj2 : null);
				if (val2 != null && InspectorTeamField?.GetValue(panel) is Team val3)
				{
					val = val2.GetWinConditionFromTeam(val3, guid);
				}
			}
			if (val == null)
			{
				return false;
			}
			object? obj3 = WinConditionPropagatorField?.GetValue(panel);
			WinConditionPropagator val4 = (WinConditionPropagator)((obj3 is WinConditionPropagator) ? obj3 : null);
			if (val4 != null && InspectorTeamField?.GetValue(panel) is Team team)
			{
				RemoveCondition(panel, val4, team, val);
			}
			else
			{
				val.OnRemovedFromgGUI();
			}
			if ((Object)(object)listItem != (Object)null)
			{
				WinConditionEditorUi.RemoveListItem(panel, listItem);
			}
			WinConditionEditorUi.FinishInspectorAfterDelete(panel);
			NotifyTeamPanel(teamPanel);
			return true;
		}

		private static void RemoveCondition(InspectorPanel panel, WinConditionPropagator propagator, Team team, WinCondition condition)
		{
			//IL_0059: 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_0068: 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)
			if (condition is MustKillAllSelectedUnitsWinCondition mustKillAllSelectedUnitsWinCondition)
			{
				WinConditionEditorUi.EndMultiKillPickSession();
				if (propagator.GetWinConditionFromTeam(team, ((WinCondition)mustKillAllSelectedUnitsWinCondition).Guid) != null)
				{
					propagator.RemoveWinCondition(team, (WinCondition)(object)mustKillAllSelectedUnitsWinCondition);
				}
				((WinCondition)mustKillAllSelectedUnitsWinCondition).OnRemovedFromgGUI();
				MultiKillTargetRegistry.Rebuild(propagator);
				Plugin.LogInfo($"Kill-all-targets: deleted condition {((WinCondition)mustKillAllSelectedUnitsWinCondition).Guid} ({mustKillAllSelectedUnitsWinCondition.TargetCount} targets).");
			}
			else
			{
				if (propagator.GetWinConditionFromTeam(team, condition.Guid) != null)
				{
					propagator.RemoveWinCondition(team, condition);
				}
				condition.OnRemovedFromgGUI();
			}
		}

		private static void NotifyTeamPanel(object teamPanel)
		{
			if (teamPanel != null)
			{
				Traverse.Create(teamPanel).Method("UpdateBackButtons", Array.Empty<object>()).GetValue();
			}
		}
	}
	internal static class WinConditionDescriptionText
	{
		private static readonly FieldInfo DescriptionTextField = AccessTools.Field(typeof(InspectorPanel), "m_descriptionText");

		internal static void Apply(InspectorPanel panel, WinCondition condition)
		{
			if ((Object)(object)panel == (Object)null || condition == null)
			{
				return;
			}
			object? obj = DescriptionTextField?.GetValue(panel);
			LocalizeText val = (LocalizeText)((obj is LocalizeText) ? obj : null);
			if (val != null)
			{
				string[] array = default(string[]);
				string text = condition.GetDescription(ref array);
				if (array != null && array.Length != 0 && text.Contains("{"))
				{
					text = SafeFormat(text, array);
				}
				val.Args = null;
				val.Localized = false;
				val.LocaleID = text;
			}
		}

		private static string SafeFormat(string format, string[] args)
		{
			try
			{
				return string.Format(format, args);
			}
			catch
			{
				return format;
			}
		}
	}
	internal static class WinConditionEditorUi
	{
		[CompilerGenerated]
		private sealed class <GetAllInspectorPanels>d__49 : IEnumerable<InspectorPanel>, IEnumerable, IEnumerator<InspectorPanel>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private InspectorPanel <>2__current;

			private int <>l__initialThreadId;

			private Object[] <>7__wrap1;

			private int <>7__wrap2;

			private IEnumerator<InspectorPanel> <>7__wrap3;

			InspectorPanel IEnumerator<InspectorPanel>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetAllInspectorPanels>d__49(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>7__wrap3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
						goto IL_00a8;
					}
					<>1__state = -1;
					if (WinConditionsComponentType == null || TeamPanelInspectorField == null)
					{
						return false;
					}
					<>7__wrap1 = Object.FindObjectsOfType(WinConditionsComponentType);
					<>7__wrap2 = 0;
					goto IL_00d0;
					IL_00d0:
					if (<>7__wrap2 < <>7__wrap1.Length)
					{
						Object winConditions = <>7__wrap1[<>7__wrap2];
						<>7__wrap3 = GetInspectorPanelsForWinConditions(winConditions).GetEnumerator();
						<>1__state = -3;
						goto IL_00a8;
					}
					<>7__wrap1 = null;
					return false;
					IL_00a8:
					if (<>7__wrap3.MoveNext())
					{
						InspectorPanel current = <>7__wrap3.Current;
						<>2__current = current;
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap3 = null;
					<>7__wrap2++;
					goto IL_00d0;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap3 != null)
				{
					<>7__wrap3.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<InspectorPanel> IEnumerable<InspectorPanel>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetAllInspectorPanels>d__49(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<InspectorPanel>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetInspectorPanelsForWinConditions>d__48 : IEnumerable<InspectorPanel>, IEnumerable, IEnumerator<InspectorPanel>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private InspectorPanel <>2__current;

			private int <>l__initialThreadId;

			private object winConditions;

			public object <>3__winConditions;

			InspectorPanel IEnumerator<InspectorPanel>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetInspectorPanelsForWinConditions>d__48(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				object obj2;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					if (winConditions == null || TeamPanelInspectorField == null)
					{
						return false;
					}
					object obj = WinConditionsRedTeamField?.GetValue(winConditions);
					if (obj != null)
					{
						object? value = TeamPanelInspectorField.GetValue(obj);
						InspectorPanel val = (InspectorPanel)((value is InspectorPanel) ? value : null);
						if (val != null)
						{
							<>2__current = val;
							<>1__state = 1;
							return true;
						}
					}
					goto IL_007f;
				}
				case 1:
					<>1__state = -1;
					goto IL_007f;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_007f:
					obj2 = WinConditionsBlueTeamField?.GetValue(winConditions);
					if (obj2 != null)
					{
						object? value2 = TeamPanelInspectorField.GetValue(obj2);
						InspectorPanel val2 = (InspectorPanel)((value2 is InspectorPanel) ? value2 : null);
						if (val2 != null)
						{
							<>2__current = val2;
							<>1__state = 2;
							return true;
						}
					}
					break;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<InspectorPanel> IEnumerable<InspectorPanel>.GetEnumerator()
			{
				<GetInspectorPanelsForWinConditions>d__48 <GetInspectorPanelsForWinConditions>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetInspectorPanelsForWinConditions>d__ = this;
				}
				else
				{
					<GetInspectorPanelsForWinConditions>d__ = new <GetInspectorPanelsForWinConditions>d__48(0);
				}
				<GetInspectorPanelsForWinConditions>d__.winConditions = <>3__winConditions;
				return <GetInspectorPanelsForWinConditions>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<InspectorPanel>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <MultiKillBackRoutine>d__70 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public InspectorPanel panel;

			private bool <selecting>5__2;

			private bool <adding>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <MultiKillBackRoutine>d__70(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					MustKillAllSelectedUnitsWinCondition multiKill = GetMultiKill(panel);
					if (multiKill == null)
					{
						return false;
					}
					object value = WinConditionsComponentField.GetValue(panel);
					if (value == null)
					{
						return false;
					}
					object obj = WinConditionsSelectingUnitField?.GetValue(value);
					int num;
					if (obj is bool)
					{
						<selecting>5__2 = (bool)obj;
						num = 1;
					}
					else
					{
						num = 0;
					}
					if (((uint)num & (<selecting>5__2 ? 1u : 0u)) != 0)
					{
						if (TryGetActiveMultiKillReferenceField(panel, out var referenceField))
						{
							CancelReferencePick(referenceField);
						}
						return false;
					}
					obj = IsAddingNewConditionField?.GetValue(panel);
					int num2;
					if (obj is bool)
					{
						<adding>5__3 = (bool)obj;
						num2 = 1;
					}
					else
					{
						num2 = 0;
					}
					if (((uint)num2 & (<adding>5__3 ? 1u : 0u)) != 0)
					{
						((WinCondition)multiKill).OnRemovedFromgGUI();
						SetWinConditionPanels(value, victoryOpen: false, browserOpen: true);
						BackToListViewMethod?.Invoke(panel, new object[1] { false });
					}
					else
					{
						SetVictoryPanelOpen(value, open: false);
						ApplyAndAbortMethod?.Invoke(panel, null);
					}
					Traverse.Create(value).Method("UpdateBackButtons", Array.Empty<object>()).GetValue();
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <RearmMultiKillPickerNextFrame>d__72 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public UIReferenceField referenceField;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RearmMultiKillPickerNextFrame>d__72(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if (!IsMultiKillPickSessionActive || (Object)(object)referenceField == (Object)null)
					{
						return false;
					}
					RestorePlacementBrush(referenceField);
					Traverse.Create((object)referenceField).Method("SwitchToReferenceBrush", Array.Empty<object>()).GetValue();
					PickModeField?.SetValue(referenceField, true);
					Traverse.Create((object)referenceField).Method("TriggerBlockInput", Array.Empty<object>()).GetValue();
					object winConditions = GetWinConditions(referenceField);
					if (winConditions != null)
					{
						WinConditionsSelectingUnitField?.SetValue(winConditions, true);
						Traverse.Create(winConditions).Method("UpdateBackButtons", Array.Empty<object>()).GetValue();
						ApplyMultiKillBackButtonState(winConditions);
					}
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly PropertyInfo PropertyOwnerProperty = AccessTools.Property(typeof(UIPropertyField), "PropertyOwner");

		private static readonly FieldInfo WinConditionsComponentField = AccessTools.Field(typeof(InspectorPanel), "m_WinConditionsComponent");

		private static readonly Type WinConditionsComponentType = WinConditionsComponentField?.FieldType;

		private static readonly FieldInfo AddConditionButtonField = AccessTools.Field(typeof(InspectorPanel), "m_AddConditionButtonGameObject");

		private static readonly FieldInfo AddConditionGlyphField = AccessTools.Field(typeof(InspectorPanel), "m_AddConditionGlyph");

		private static readonly FieldInfo EditConditionGlyphField = AccessTools.Field(typeof(InspectorPanel), "m_EditConditionGlyph");

		private static readonly FieldInfo ActionGlyphField = AccessTools.Field(typeof(InspectorPanel), "m_ActionGlyph");

		private static readonly FieldInfo InspectedConditionField = AccessTools.Field(typeof(InspectorPanel), "m_currentlyInspectedCondition");

		private static readonly FieldInfo BoundGuidField = AccessTools.Field(typeof(InspectorPanel), "m_boundGuid");

		private static readonly FieldInfo IsAddingNewConditionField = AccessTools.Field(typeof(InspectorPanel), "m_IsAddingNewCondition");

		private static readonly FieldInfo BoundItemField = AccessTools.Field(typeof(InspectorPanel), "m_boundItem");

		private static readonly FieldInfo CachedConditionField = AccessTools.Field(typeof(InspectorPanel), "m_cachedCondition");

		private static readonly FieldInfo IsShowingField = AccessTools.Field(typeof(InspectorPanel), "m_isShowing");

		private static readonly FieldInfo TeamListField = AccessTools.Field(typeof(InspectorPanel), "m_teamList");

		private static readonly MethodInfo ShowAddButtonMethod = AccessTools.Method(typeof(InspectorPanel), "ShowAddButton", (Type[])null, (Type[])null);

		private static readonly MethodInfo ShowApplyAndDeleteButtonMethod = AccessTools.Method(typeof(InspectorPanel), "ShowApplyAndDeleteButton", (Type[])null, (Type[])null);

		private static readonly MethodInfo BackToListViewMethod = AccessTools.Method(typeof(InspectorPanel), "BackToListView", (Type[])null, (Type[])null);

		private static readonly MethodInfo UpdateFromCurrentWinconditionsMethod = AccessTools.Method(typeof(InspectorPanel), "UpdateFromCurrentWinconditions", (Type[])null, (Type[])null);

		private static readonly MethodInfo PlayContentAnimatorOutMethod = AccessTools.Method(typeof(InspectorPanel), "PlayContentAnimatorOut", (Type[])null, (Type[])null);

		private static readonly MethodInfo PlayContentAnimatorInMethod = AccessTools.Method(typeof(InspectorPanel), "PlayContentAnimatorIn", (Type[])null, (Type[])null);

		private static readonly MethodInfo ApplyAndAbortMethod = AccessTools.Method(typeof(InspectorPanel), "ApplyAndAbort", (Type[])null, (Type[])null);

		private static readonly FieldInfo PickModeField = AccessTools.Field(typeof(UIReferenceField), "m_isInPickMode");

		private static readonly FieldInfo PickedReferenceField = AccessTools.Field(typeof(UIReferenceField), "m_pickedRuntimeReference");

		private static readonly FieldInfo ReferenceFieldWinConditionsField = AccessTools.Field(typeof(UIReferenceField), "m_WinConditionsComponent");

		private static readonly FieldInfo WinConditionsSelectingUnitField = ((WinConditionsComponentType != null) ? AccessTools.Field(WinConditionsComponentType, "m_IsSelectingUnit") : null);

		private static readonly FieldInfo WinConditionsAnimatePanelsField = ((WinConditionsComponentType != null) ? AccessTools.Field(WinConditionsComponentType, "m_animateMainPanels") : null);

		private static readonly FieldInfo WinConditionsUnitPromptField = ((WinConditionsComponentType != null) ? AccessTools.Field(WinConditionsComponentType, "m_UnitSelectPrompt") : null);

		private static readonly FieldInfo WinConditionsTimeServiceField = ((WinConditionsComponentType != null) ? AccessTools.Field(WinConditionsComponentType, "m_timeService") : null);

		private static readonly FieldInfo WinConditionsRootBackButtonField = ((WinConditionsComponentType != null) ? AccessTools.Field(WinConditionsComponentType, "m_RootBackButton") : null);

		private static readonly FieldInfo WinConditionsEditUnitBackButtonField = ((WinConditionsComponentType != null) ? AccessTools.Field(WinConditionsComponentType, "m_BackButtonEditUnitCondition") : null);

		private static readonly FieldInfo WinConditionsRedTeamField = ((WinConditionsComponentType != null) ? AccessTools.Field(WinConditionsComponentType, "m_RedTeamPanelConditions") : null);

		private static readonly FieldInfo WinConditionsBlueTeamField = ((WinConditionsComponentType != null) ? AccessTools.Field(WinConditionsComponentType, "m_BlueTeamPanelConditions") : null);

		private static readonly FieldInfo TeamPanelInspectorField = ((WinConditionTypeResolver.WinConditionsTeamPanelType != null) ? AccessTools.Field(WinConditionTypeResolver.WinConditionsTeamPanelType, "m_WinConditionInspectorPanel") : null);

		private static int _lastAnyMultiKillCheckFrame = -1;

		private static bool _cachedAnyInspectorHasMultiKill;

		private static int _lastMultiKillEnsureFrame = -1;

		private static InspectorPanel _lastMultiKillEnsurePanel;

		internal static bool IsMultiKillPickSessionActive { get; private set; }

		internal static bool SuppressInspectorOpenForDelete { get; set; }

		internal static void EndMultiKillPickSession()
		{
			IsMultiKillPickSessionActive = false;
			MultiKillInspectorChrome.ResetForPanel(_lastMultiKillEnsurePanel);
		}

		public static bool AnyInspectorHasMultiKill()
		{
			if (Time.frameCount == _lastAnyMultiKillCheckFrame)
			{
				return _cachedAnyInspectorHasMultiKill;
			}
			_lastAnyMultiKillCheckFrame = Time.frameCount;
			if (IsMultiKillPickSessionActive)
			{
				_cachedAnyInspectorHasMultiKill = true;
				return true;
			}
			foreach (InspectorPanel allInspectorPanel in GetAllInspectorPanels())
			{
				if (GetMultiKill(allInspectorPanel) != null)
				{
					_cachedAnyInspectorHasMultiKill = true;
					return true;
				}
			}
			_cachedAnyInspectorHasMultiKill = false;
			return false;
		}

		internal static InspectorPanel FindInspectorInspectingCondition(WinCondition condition)
		{
			if (condition == null)
			{
				return null;
			}
			foreach (InspectorPanel allInspectorPanel in GetAllInspectorPanels())
			{
				if (GetInspectedCondition(allInspectorPanel) == condition)
				{
					return allInspectorPanel;
				}
			}
			return null;
		}

		[IteratorStateMachine(typeof(<GetInspectorPanelsForWinConditions>d__48))]
		internal static IEnumerable<InspectorPanel> GetInspectorPanelsForWinConditions(object winConditions)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetInspectorPanelsForWinConditions>d__48(-2)
			{
				<>3__winConditions = winConditions
			};
		}

		[IteratorStateMachine(typeof(<GetAllInspectorPanels>d__49))]
		internal static IEnumerable<InspectorPanel> GetAllInspectorPanels()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAllInspectorPanels>d__49(-2);
		}

		public static void ApplyMultiKillBackButtonState(object winConditions)
		{
			if (winConditions == null)
			{
				return;
			}
			InspectorPanel val = null;
			foreach (InspectorPanel inspectorPanelsForWinCondition in GetInspectorPanelsForWinConditions(winConditions))
			{
				if (GetMultiKill(inspectorPanelsForWinCondition) != null)
				{
					val = inspectorPanelsForWinCondition;
					break;
				}
			}
			if (!((Object)(object)val == (Object)null) || IsMultiKillPickSessionActive)
			{
				HideRootBackButton(winConditions);
				bool value = Traverse.Create(winConditions).Property("VictoryConditionsPanelIsOpen", (object[])null).GetValue<bool>();
				if ((Object)(object)val != (Object)null && value)
				{
					HideEditUnitBackButton(winConditions);
				}
				if ((Object)(object)val != (Object)null)
				{
					MultiKillInspectorChrome.Apply(val, winConditions);
				}
			}
		}

		public static object GetWinConditionsComponent(InspectorPanel panel)
		{
			return WinConditionsComponentField?.GetValue(panel);
		}

		public static WinCondition GetInspectedCondition(InspectorPanel panel)
		{
			object? obj = InspectedConditionField?.GetValue(panel);
			return (WinCondition)((obj is WinCondition) ? obj : null);
		}

		internal static void PrepareAddFromBrowserIfNeeded(InspectorPanel panel)
		{
			if (!((Object)(object)panel == (Object)null) && BoundItemField?.GetValue(panel) == null)
			{
				BoundGuidField?.SetValue(panel, Guid.Empty);
				IsAddingNewConditionField?.SetValue(panel, true);
				CachedConditionField?.SetValue(panel, null);
				IsShowingField?.SetValue(panel, true);
			}
		}

		internal static void ShowAddButtonForPanel(InspectorPanel panel)
		{
			ShowAddButtonMethod?.Invoke(panel, null);
		}

		internal static void ShowApplyAndDeleteForPanel(InspectorPanel panel)
		{
			ShowApplyAndDeleteButtonMethod?.Invoke(panel, null);
		}

		public static MustKillAllSelectedUnitsWinCondition GetMultiKill(InspectorPanel panel)
		{
			return GetInspectedCondition(panel) as MustKillAllSelectedUnitsWinCondition;
		}

		public static InspectorPanel GetInspectorPanel(UIReferenceField referenceField)
		{
			return ((Component)referenceField).GetComponentInParent<InspectorPanel>();
		}

		public static bool IsMultiKillAddTargetField(UIReferenceField referenceField)
		{
			return PropertyOwnerProperty.GetValue(referenceField, null) is MustKillAllSelectedUnitsWinCondition;
		}

		public static void RestorePlacementBrush(UIReferenceField referenceField)
		{
			Traverse.Create((object)referenceField).Method("RestoreBrush", Array.Empty<object>()).GetValue();
			PickModeField?.SetValue(referenceField, false);
		}

		public static void CancelReferencePick(UIReferenceField referenceField)
		{
			IsMultiKillPickSessionActive = false;
			RestorePlacementBrush(referenceField);
			PickedReferenceField?.SetValue(referenceField, null);
			Traverse.Create((object)referenceField).Method("UpdateUI", Array.Empty<object>()).GetValue();
			ReopenInspectorAfterPick(referenceField);
			InspectorPanel inspectorPanel = GetInspectorPanel(referenceField);
			if (inspectorPanel != null)
			{
				EnsureMultiKillInspectorReady(inspectorPanel);
			}
		}

		public static void FinishReferencePick(UIReferenceField referenceField, RuntimeReference reference)
		{
			if (reference == null)
			{
				CancelReferencePick(referenceField);
				return;
			}
			object value = PropertyOwnerProperty.GetValue(referenceField, null);
			if (value is MustKillAllSelectedUnitsWinCondition mustKillAllSelectedUnitsWinCondition)
			{
				Guid guid = reference.Guid;
				InspectorPanel inspectorPanel = GetInspectorPanel(referenceField);
				ReferenceRenderer renderer = (ReferenceRenderer)(((Object)(object)inspectorPanel != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
				if (mustKillAllSelectedUnitsWinCondition.ContainsTarget(guid))
				{
					mustKillAllSelectedUnitsWinCondition.RemoveTarget(guid);
				}
				else
				{
					ReferenceRequest<Unit> val = new ReferenceRequest<Unit>(guid.ToString());
					mustKillAllSelectedUnitsWinCondition.AddTarget(val);
					MultiKillTargetIcons.EnsureIcon(renderer, val);
				}
				PickedReferenceField?.SetValue(referenceField, null);
				value.GetType().GetField("m_addTargetPicker", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(value, null);
				Traverse.Create((object)referenceField).Method("UpdateUI", Array.Empty<object>()).GetValue();
				PickModeField?.SetValue(referenceField, true);
				ContinueMultiKillUnitPick(referenceField);
				((MonoBehaviour)referenceField).StartCoroutine(RearmMultiKillPickerNextFrame(referenceField));
				WinConditionUiRefresh.RefreshMultiKillEditor(mustKillAllSelectedUnitsWinCondition, inspectorPanel);
			}
		}

		public static void BeginMultiKillUnitPick(UIReferenceField referenceField)
		{
			IsMultiKillPickSessionActive = true;
			MultiKillInspectorChrome.ResetForPanel(GetInspectorPanel(referenceField));
			Traverse.Create((object)referenceField).Method("SwitchToReferenceBrush", Array.Empty<object>()).GetValue();
			object winConditions = GetWinConditions(referenceField);
			if (winConditions != null)
			{
				Traverse.Create(winConditions).Method("HideForUnitSelect", Array.Empty<object>()).GetValue();
			}
			Traverse.Create((object)referenceField).Method("TriggerBlockInput", Array.Empty<object>()).GetValue();
		}

		private static void ContinueMultiKillUnitPick(UIReferenceField referenceField)
		{
			IsMultiKillPickSessionActive = true;
			object winConditions = GetWinConditions(referenceField);
			if (winConditions != null)
			{
				WinConditionsSelectingUnitField?.SetValue(winConditions, true);
				SetVictoryPanelOpen(winConditions, open: false);
				Traverse.Create(winConditions).Method("UpdateBackButtons", Array.Empty<object>()).GetValue();
				ApplyMultiKillBackButtonState(winConditions);
				object? obj = WinConditionsUnitPromptField?.GetValue(winConditions);
				GameObject val = (GameObject)((obj is GameObject) ? obj : null);
				if (val != null)
				{
					val.SetActive(true);
				}
				UnpauseForMapPicks(winConditions);
			}
		}

		private static void ReopenInspectorAfterPick(UIReferenceField referenceField)
		{
			IsMultiKillPickSessionActive = false;
			object winConditions = GetWinConditions(referenceField);
			if (winConditions != null)
			{
				WinConditionsSelectingUnitField?.SetValue(winConditions, false);
				WinConditionsAnimatePanelsField?.SetValue(winConditions, false);
				SetVictoryPanelOpen(winConditions, open: true);
				WinConditionsAnimatePanelsField?.SetValue(winConditions, true);
				Traverse.Create(winConditions).Method("UpdateBackButtons", Array.Empty<object>()).GetValue();
				ApplyMultiKillBackButtonState(winConditions);
				object? obj = WinConditionsUnitPromptField?.GetValue(winConditions);
				GameObject val = (GameObject)((obj is GameObject) ? obj : null);
				if (val != null)
				{
					val.SetActive(false);
				}
				PauseForInspector(winConditions);
				UIScreenInputBlocker.SetBlockCameraMovement(true);
			}
		}

		public static void EnsureMultiKillInspectorReady(InspectorPanel panel)
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Invalid comparison between Unknown and I4
			if ((Object)(object)panel == (Object)null || GetMultiKill(panel) == null || SuppressInspectorOpenForDelete || (Time.frameCount == _lastMultiKillEnsureFrame && (Object)(object)_lastMultiKillEnsurePanel == (Object)(object)panel))
			{
				return;
			}
			_lastMultiKillEnsureFrame = Time.frameCount;
			_lastMultiKillEnsurePanel = panel;
			object? obj = AccessTools.Field(typeof(InspectorPanel), "m_fieldController")?.GetValue(panel);
			FieldController val = (FieldController)((obj is FieldController) ? obj : null);
			if (val != null)
			{
				val.TurnOnEditButton();
			}
			Guid obj2 = ((BoundGuidField?.GetValue(panel) is Guid guid) ? guid : Guid.Empty);
			if (obj2 == Guid.Empty)
			{
				IsAddingNewConditionField?.SetValue(panel, true);
				ShowAddButtonMethod?.Invoke(panel, null);
			}
			else
			{
				panel.UpdateAddButton();
			}
			panel.UpdateAddButton();
			object? value = AddConditionButtonField.GetValue(panel);
			GameObject val2 = (GameObject)((value is GameObject) ? value : null);
			if (val2 != null)
			{
				val2.SetActive(true);
			}
			object? value2 = AddConditionGlyphField.GetValue(panel);
			GameObject val3 = (GameObject)((value2 is GameObject) ? value2 : null);
			if (val3 != null)
			{
				val3.SetActive(true);
			}
			object? value3 = ActionGlyphField.GetValue(panel);
			ActionGlyphText val4 = (ActionGlyphText)((value3 is ActionGlyphText) ? value3 : null);
			if (val4 != null)
			{
				val4.UpdateActionNames("Add Victory Conditions From Inspector", "APPLY");
			}
			object? value4 = EditConditionGlyphField.GetValue(panel);
			GameObject val5 = (GameObject)((value4 is GameObject) ? value4 : null);
			if (val5 != null)
			{
				bool active = PlayerActions.Instance != null && (int)PlayerActions.Instance.InputType == 0;
				val5.SetActive(active);
			}
			object value5 = WinConditionsComponentField.GetValue(panel);
			if (value5 != null)
			{
				if (!IsMultiKillPickSessionActive)
				{
					WinConditionsSelectingUnitField?.SetValue(value5, false);
				}
				Traverse.Create(value5).Method("UpdateBackButtons", Array.Empty<object>()).GetValue();
			}
			ApplyMultiKillBackButtonState(value5);
			MultiKillTargetFieldUi.RefreshAllFields(GetMultiKill(panel), panel);
			MultiKillInspectorChrome.ApplyDeferred(panel);
			if (obj2 == Guid.Empty && !SuppressInspectorOpenForDelete)
			{
				PlayContentAnimatorInMethod?.Invoke(panel, null);
			}
		}

		public static void ClearInspectorAfterDelete(InspectorPanel panel)
		{
			if (!((Object)(object)panel == (Object)null))
			{
				BoundItemField?.SetValue(panel, null);
				InspectedConditionField?.SetValue(panel, null);
				CachedConditionField?.SetValue(panel, null);
				BoundGuidField?.SetValue(panel, Guid.Empty);
				IsShowingField?.SetValue(panel, false);
			}
		}

		public static void FinishInspectorAfterDelete(InspectorPanel panel)
		{
			if (!((Object)(object)panel == (Object)null))
			{
				EndMultiKillPickSession();
				ClearInspectorAfterDelete(panel);
				PlayContentAnimatorOutMethod?.Invoke(panel, null);
				UpdateFromCurrentWinconditionsMethod?.Invoke(panel, null);
				object winConditionsComponent = GetWinConditionsComponent(panel);
				if (winConditionsComponent != null)
				{
					SetVictoryPanelOpen(winConditionsComponent, open: false);
					Traverse.Create(winConditionsComponent).Method("UpdateBackButtons", Array.Empty<object>()).GetValue();
				}
			}
		}

		public static void RemoveListItem(InspectorPanel panel, object item)
		{
			if (!((Object)(object)panel == (Object)null) && item != null)
			{
				object obj = TeamListField?.GetValue(panel);
				obj?.GetType().GetMethod("RemoveItem")?.Invoke(obj, new object[1] { item });
			}
		}

		public static bool TryGetActiveMultiKillReferenceField(InspectorPanel panel, out UIReferenceField referenceField)
		{
			referenceField = null;
			if ((Object)(object)panel == (Object)null)
			{
				return false;
			}
			UIReferenceField[] componentsInChildren = ((Component)panel).GetComponentsInChildren<UIReferenceField>(true);
			foreach (UIReferenceField val in componentsInChildren)
			{
				if (IsMultiKillAddTargetField(val))
				{
					referenceField = val;
					return true;
				}
			}
			return false;
		}

		[IteratorStateMachine(typeof(<MultiKillBackRoutine>d__70))]
		public static IEnumerator MultiKillBackRoutine(InspectorPanel panel)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MultiKillBackRoutine>d__70(0)
			{
				panel = panel
			};
		}

		internal static void SetWinConditionPanels(object winConditions, bool victoryOpen, bool browserOpen)
		{
			if (winConditions != null)
			{
				WinConditionsAnimatePanelsField?.SetValue(winConditions, false);
				SetVictoryPanelOpen(winConditions, victoryOpen);
				if (browserOpen)
				{
					Traverse.Create(winConditions).Method("OpenConditionBrowserPanel", new object[1] { true }).GetValue();
				}
				WinConditionsAnimatePanelsField?.SetValue(winConditions, true);
				ApplyMultiKillBackButtonState(winConditions);
			}
		}

		[IteratorStateMachine(typeof(<RearmMultiKillPickerNextFrame>d__72))]
		private static IEnumerator RearmMultiKillPickerNextFrame(UIReferenceField referenceField)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RearmMultiKillPickerNextFrame>d__72(0)
			{
				referenceField = referenceField
			};
		}

		private static object GetWinConditions(UIReferenceField referenceField)
		{
			object obj = ReferenceFieldWinConditionsField?.GetValue(referenceField);
			if (obj == null)
			{
				InspectorPanel inspectorPanel = GetInspectorPanel(referenceField);
				if (inspectorPanel == null)
				{
					return null;
				}
				obj = WinConditionsComponentField.GetValue(inspectorPanel);
			}
			return obj;
		}

		private static void SetVictoryPanelOpen(object winConditions, bool open)
		{
			Traverse.Create(winConditions).Method("OpenVictoryConditionPanel", new object[1] { open }).GetValue();
		}

		private static void UnpauseForMapPicks(object winConditions)
		{
			WinConditionsTimeServiceField?.GetValue(winConditions)?.GetType().GetMethod("UnPause")?.Invoke(WinConditionsTimeServiceField.GetValue(winConditions), null);
			UIScreenInputBlocker.SetBlockCameraMovement(false);
		}

		private static void PauseForInspector(object winConditions)
		{
			WinConditionsTimeServiceField?.GetValue(winConditions)?.GetType().GetMethod("Pause")?.Invoke(WinConditionsTimeServiceField.GetValue(winConditions), null);
		}

		private static void HideRootBackButton(object winConditions)
		{
			object? obj = WinConditionsRootBackButtonField?.GetValue(winConditions);
			Component val = (Component)((obj is Component) ? obj : null);
			if (val != null)
			{
				val.gameObject.SetActive(false);
			}
		}

		private static void HideEditUnitBackButton(object winConditions)
		{
			object? obj = WinConditionsEditUnitBackButtonField?.GetValue(winConditions);
			Component val = (Component)((obj is Component) ? obj : null);
			if (val != null)
			{
				val.gameObject.SetActive(false);
			}
		}
	}
	internal static class WinConditionFieldLabels
	{
		private static readonly FieldInfo OverrideLabelField = AccessTools.Field(typeof(UIPropertyField), "m_OverrideLabel");

		private static readonly FieldInfo LabelField = AccessTools.Field(typeof(UIPropertyField), "m_label");

		internal static void Force(UIPropertyField field, string text)
		{
			if (!((Object)(object)field == (Object)null) && !string.IsNullOrEmpty(text))
			{
				OverrideLabelField?.SetValue(field, true);
				field.SetPropertyLabel(text);
				if (LabelField?.GetValue(field) != null)
				{
					LabelField.GetValue(field).GetType().GetProperty("text")?.SetValue(LabelField.GetValue(field), text, null);
				}
				LocalizeText[] componentsInChildren = ((Component)field).GetComponentsInChildren<LocalizeText>(true);
				foreach (LocalizeText obj in componentsInChildren)
				{
					obj.Localized = false;
					obj.LocaleID = text;
				}
			}
		}
	}
	internal static class WinConditionTypeResolver
	{
		private static Type _winConditionsTeamPanelType;

		internal static Type WinConditionsTeamPanelType => _winConditionsTeamPanelType ?? (_winConditionsTeamPanelType = Resolve("TFBGames.WinConditionsTeamPanel", "WinConditionsTeamPanel"));

		private static Type Resolve(params string[] names)
		{
			string[] array = names;
			for (int i = 0; i < array.Length; i++)
			{
				Type type = AccessTools.TypeByName(array[i]);
				if (type != null)
				{
					return type;
				}
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (assembly.IsDynamic)
				{
					continue;
				}
				array = names;
				foreach (string text in array)
				{
					string text2 = text;
					int num = text.LastIndexOf('.');
					if (num >= 0 && num < text.Length - 1)
					{
						text2 = text.Substring(num + 1);
					}
					try
					{
						Type type2 = assembly.GetType(text, throwOnError: false);
						if (type2 != null)
						{
							return type2;
						}
						Type[] types = assembly.GetTypes();
						foreach (Type type3 in types)
						{
							if (type3.Name == text2)
							{
								return type3;
							}
						}
					}
					catch (ReflectionTypeLoadException)
					{
					}
				}
			}
			return null;
		}
	}
	internal static class WinConditionUiPatches
	{
		private static readonly FieldInfo InspectedConditionField = AccessTools.Field(typeof(InspectorPanel), "m_currentlyInspectedCondition");

		private static readonly PropertyInfo PropertyOwnerProperty = AccessTools.Property(typeof(UIPropertyField), "PropertyOwner");

		private static readonly FieldInfo BoundItemField = AccessTools.Field(typeof(InspectorPanel), "m_boundItem");

		private static readonly FieldInfo InspectorRefRendererField = AccessTools.Field(typeof(InspectorPanel), "m_RefRenderer");

		private static readonly FieldInfo PresenterPropagatorField = AccessTools.Field(typeof(WinConditionPresenter), "m_winConditionPropagator");

		private static readonly FieldInfo BoundGuidField = AccessTools.Field(typeof(InspectorPanel), "m_boundGuid");

		private static readonly FieldInfo WinConditionPropagatorField = AccessTools.Field(typeof(InspectorPanel), "m_winConditionPropagator");

		private static readonly FieldInfo InspectorTeamField = AccessTools.Field(typeof(InspectorPanel), "m_team");

		private static readonly Type WinConditionsComponentType = AccessTools.Field(typeof(InspectorPanel), "m_WinConditionsComponent")?.FieldType;

		private static readonly MethodInfo PresenterShowConditionsMethod = AccessTools.Method(typeof(WinConditionPresenter), "ShowConditions", (Type[])null, (Type[])null);

		private static ReferenceRenderer _cachedReferenceRenderer;

		private static readonly FieldInfo EvaluatorConditionsField = AccessTools.Field(typeof(WinConditionEvaluator), "m_winConditions");

		internal static void Register(Harmony harmony, ref int applied)
		{
			applied += Patch(harmony, typeof(InspectorPanel), "IsInspectingMustWinCondition", (string)null, "IsInspectingMustWinCondition_Postfix");
			applied += Patch(harmony, typeof(InspectorPanel), "CanApplyInspectedMustKillCondition", (string)null, "CanApplyInspectedMustKillCondition_Postfix");
			applied += Patch(harmony, typeof(InspectorPanel), "CanShowApplyButtonForInspectedCondition", (string)null, "CanShowApplyButtonForInspectedCondition_Postfix");
			Type winConditionsTeamPanelType = WinConditionTypeResolver.WinConditionsTeamPanelType;
			if (winConditionsTeamPanelType != null)
			{
				applied += Patch(harmony, winConditionsTeamPanelType, "RemoveSelectedCondition", new Type[1] { typeof(UIListItem) }, "RemoveSelectedCondition_Prefix");
				applied += Patch(harmony, winConditionsTeamPanelType, "RemoveAllConditions", "RemoveAllConditions_Prefix");
				Plugin.LogInfo("Win conditions: patched TFBGames.WinConditionsTeamPanel list delete.");
			}
			else
			{
				Plugin.LogWarning("Win conditions: WinConditionsTeamPanel type not found — list delete may open inspector.");
			}
			applied += Patch(harmony, typeof(InspectorPanel), "BindWinCondition", new Type[2]
			{
				typeof(Guid),
				typeof(UIListItem)
			}, null, "BindWinCondition_Postfix");
			applied += Patch(harmony, typeof(InspectorPanel), "InspectNewCondition", (string)null, "InspectNewCondition_Postfix");
			applied += Patch(harmony, typeof(InspectorPanel), "OnWinConditionChanged", new Type[1] { typeof(int) }, "OnWinConditionChanged_Prefix", "OnWinConditionChanged_Postfix");
			applied += Patch(harmony, typeof(InspectorPanel), "SetInspectedCondition", new Type[1] { typeof(Guid) }, "SetInspectedCondition_Prefix");
			applied += Patch(harmony, typeof(UIReferenceField), "OnClickedReferenceButton", "OnClickedReferenceButton_Prefix");
			applied += Patch(harmony, typeof(UIReferenceField), "UpdateUI", "UIReferenceField_UpdateUI_Prefix");
			MethodInfo original = AccessTools.Method(typeof(UIPropertyField), "BindObject", (Type[])null, (Type[])null);
			applied += Patch(harmony, original, typeof(WinConditionUiPatches), "UIPropertyField_BindObject_Prefix");
			applied += Patch(harmony, typeof(UIReferenceField), "ReferencePickFinished", "ReferencePickFinished_Prefix");
			applied += Patch(harmony, typeof(InspectorPanel), "BackButtonActions", "BackButtonActions_Prefix");
			applied += Patch(harmony, typeof(InspectorPanel), "RemoveInspectedWinCondition", "RemoveInspectedWinCondition_Prefix");
			applied += Patch(harmony, typeof(InspectorPanel), "CheckWinConditionExists", new Type[1] { typeof(UIListItem) }, "CheckWinConditionExists_Prefix");
			if (WinConditionsComponentType != null)
			{
				applied += Patch(harmony, WinConditionsComponentType, "UpdateBackButtons", (string)null, "UpdateBackButtons_Postfix");
				applied += Patch(harmony, WinConditionsComponentType, "ShowAfterUnitSelected", "ShowAfterUnitSelected_Prefix");
			}
			applied += Patch(harmony, typeof(WinConditionEvaluator), "IsUnitMustKill", (string)null, "IsUnitMustKill_Postfix");
			applied += Patch(harmony, typeof(InspectorPanel), "GetUpdateConditionIcons", new Type[1] { typeof(WinCondition) }, null, "GetUpdateConditionIcons_Postfix");
			applied += Patch(harmony, typeof(WinConditionListController), "StartHighlightUnit", new Type[1] { typeof(UIListItem) }, null, "StartHighlightUnit_Postfix");
			applied += Patch(harmony, typeof(WinConditionListController), "EndHighlightUnit", new Type[1] { typeof(UIListItem) }, null, "EndHighlightUnit_Postfix");
			applied += Patch(harmony, typeof(WinConditionPresenter), "OnUnitRemoved", "WinConditionPresenter_OnUnitRemoved_Prefix");
			applied += Patch(harmony, typeof(BaseGameMode), "OnExitBattleState", (string)null, "BaseGameMode_OnExitBattleState_Postfix");
			applied += Patch(harmony, typeof(InspectorPanel), "SetInspectedCondition", new Type[1] { typeof(Guid) }, null, "SetInspectedCondition_Postfix");
			applied += Patch(harmony, typeof(FieldController), "BindObject", (string)null, "FieldController_BindObject_Postfix");
			applied += Patch(harmony, typeof(InspectorPanel), "ApplyWinCondition", (string)null, "ApplyWinCondition_Postfix");
			applied += Patch(harmony, typeof(InspectorPanel), "ShowApplyAndDeleteButton", (string)null, "ShowApplyAndDeleteButton_Postfix");
			applied += Patch(harmony, typeof(ReferenceRenderer), "CheckUnitReferenceIsValid", new Type[1] { typeof(Unit) }, null, "CheckUnitReferenceIsValid_Postfix");
			applied += Patch(harmony, typeof(ReferenceRenderer), "OnDestroy", (string)null, "ReferenceRenderer_OnDestroy_Postfix");
			applied += Patch(harmony, typeof(WinConditionPropagator), "AddWinCondition", new Type[2]
			{
				typeof(Team),
				typeof(WinCondition)
			}, null, "WinConditionPropagator_AddWinCondition_Postfix");
		}

		private static int Patch(Harmony harmony, Type type, string method, Type[] args, string prefix = null, string postfix = null)
		{
			MethodInfo original = AccessTools.Method(type, method, args, (Type[])null);
			return Patch(harmony, original, type, prefix, postfix);
		}

		private static int Patch(Harmony harmony, Type type, string method, string prefix = null, string postfix = null)
		{
			MethodInfo original = AccessTools.Method(type, method, (Type[])null, (Type[])null);
			return Patch(harmony, original, type, prefix, postfix);
		}

		private static int Patch(Harmony harmony, MethodBase original, Type patchClass, string prefix = null, string postfix = null)
		{
			//IL_0040: 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)
			if (original == null)
			{
				Plugin.LogWarning("Win condition UI patch missing: " + patchClass.Name + "." + (prefix ?? postfix));
				return 0;
			}
			object obj = harmony;
			obj = original;
			obj = (object)((prefix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(typeof(WinConditionUiPatches), prefix, (Type[])null));
			obj = (object)((postfix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(typeof(WinConditionUiPatches), postfix, (Type[])null));
			((Harmony)obj).Patch((MethodBase)obj, (HarmonyMethod)obj, (HarmonyMethod)obj, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			return 1;
		}

		private static MustKillAllSelectedUnitsWinCondition GetMultiKill(InspectorPanel panel)
		{
			return WinConditionEditorUi.GetMultiKill(panel);
		}

		private static void RefreshDescription(InspectorPanel panel, WinCondition condition)
		{
			WinConditionDescriptionText.Apply(panel, condition);
		}

		internal static ReferenceRenderer GetReferenceRenderer()
		{
			if ((Object)(object)_cachedReferenceRenderer == (Object)null)
			{
				_cachedReferenceRenderer = Object.FindObjectOfType<ReferenceRenderer>();
			}
			return _cachedReferenceRenderer;
		}

		private static void RefreshMultiKillUi(MustKillAllSelectedUnitsWinCondition condition, InspectorPanel inspector = null)
		{
			if (condition != null)
			{
				if (inspector == null)
				{
					inspector = WinConditionEditorUi.FindInspectorInspectingCondition((WinCondition)(object)condition);
				}
				WinConditionUiRefresh.UpdateMultiKillDisplays(condition, inspector);
				if ((Object)(object)inspector != (Object)null)
				{
					RefreshDescription(inspector, (WinCondition)(object)condition);
				}
			}
		}

		private static void SyncMultiKillCondition(MustKillAllSelectedUnitsWinCondition condition, InspectorPanel inspector = null)
		{
			if (condition != null)
			{
				SyncMultiKillMapIcons(condition, inspector);
				RefreshMultiKillUi(condition, inspector);
				MultiKillTargetFieldUi.RefreshAllFields(condition, inspector);
			}
		}

		private static void SyncMultiKillMapIcons(MustKillAllSelectedUnitsWinCondition condition, InspectorPanel inspector = null)
		{
			if (condition != null)
			{
				ReferenceRenderer val = (ReferenceRenderer)(((Object)(object)inspector != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
				if (val == null)
				{
					val = GetReferenceRenderer();
				}
				MultiKillTargetIcons.RefreshCondition(val, condition);
			}
		}

		public static void IsInspectingMustWinCondition_Postfix(InspectorPanel __instance, ref bool __result)
		{
			if (!__result && GetMultiKill(__instance) != null)
			{
				__result = true;
			}
		}

		public static void CanApplyInspectedMustKillCondition_Postfix(InspectorPanel __instance, ref bool __result)
		{
			MustKillAllSelectedUnitsWinCondition multiKill = GetMultiKill(__instance);
			if (multiKill != null)
			{
				Guid guid2 = ((BoundGuidField?.GetValue(__instance) is Guid guid) ? guid : Guid.Empty);
				if (multiKill.TargetCount > 0 || guid2 == Guid.Empty)
				{
					__result = true;
				}
			}
		}

		public static void CanShowApplyButtonForInspectedCondition_Postfix(InspectorPanel __instance, ref bool __result)
		{
			if (!__result && InspectedConditionField?.GetValue(__instance) is KillEnemyCountWinCondition)
			{
				__result = true;
			}
		}

		public static bool RemoveSelectedCondition_Prefix(object __instance, UIListItem listItem)
		{
			return !WinConditionDeletion.DeleteFromListItem(GetTeamPanelInspector(__instance), listItem, __instance);
		}

		public static bool RemoveAllConditions_Prefix(object __instance)
		{
			InspectorPanel teamPanelInspector = GetTeamPanelInspector(__instance);
			if ((Object)(object)teamPanelInspector == (Object)null)
			{
				return true;
			}
			object? obj = AccessTools.Field(__instance.GetType(), "m_ConditionsListContainer")?.GetValue(__instance);
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			if (val == null)
			{
				return true;
			}
			UIListItem[] componentsInChildren = val.GetComponentsInChildren<UIListItem>();
			for (int num = componentsInChildren.Length - 1; num >= 0; num--)
			{
				UIListItem val2 = componentsInChildren[num];
				if ((Object)(object)val2 != (Object)null)
				{
					WinConditionDeletion.DeleteFromListItem(teamPanelInspector, val2, __instance);
				}
			}
			return false;
		}

		private static InspectorPanel GetTeamPanelInspector(object teamPanel)
		{
			if (teamPanel == null)
			{
				return null;
			}
			object? obj = AccessTools.Field(teamPanel.GetType(), "m_WinConditionInspectorPanel")?.GetValue(teamPanel);
			return (InspectorPanel)((obj is InspectorPanel) ? obj : null);
		}

		public static bool SetInspectedCondition_Prefix(InspectorPanel __instance)
		{
			if (WinConditionEditorUi.SuppressInspectorOpenForDelete)
			{
				return false;
			}
			return true;
		}

		public static void InspectNewCondition_Postfix(InspectorPanel __instance)
		{
			if (KillEnemyCountEditorUi.IsKillEnemyCount(__instance))
			{
				WinConditionDescriptionText.Apply(__instance, WinConditionEditorUi.GetInspectedCondition(__instance));
				KillEnemyCountEditorUi.EnsureInspector(__instance);
			}
			else if (GetMultiKill(__instance) != null)
			{
				WinConditionEditorUi.EnsureMultiKillInspectorReady(__instance);
				RefreshDescription(__instance, (WinCondition)(object)GetMultiKill(__instance));
			}
		}

		public static bool OnWinConditionChanged_Prefix(InspectorPanel __instance, int newIndex)
		{
			WinConditionEditorUi.PrepareAddFromBrowserIfNeeded(__instance);
			if (!KillEnemyCountEditorUi.ShouldBlockTypeCarouselChange(__instance, newIndex))
			{
				return true;
			}
			KillEnemyCountEditorUi.RestoreSliderToInspectedType(__instance);
			return false;
		}

		public static void BindWinCondition_Postfix(InspectorPanel __instance, Guid winConditionGuid)
		{
			if (!(winConditionGuid != Guid.Empty) && KillEnemyCountEditorUi.IsKillEnemyCount(__instance))
			{
				KillEnemyCountEditorUi.EnsureInspector(__instance);
			}
		}

		public static void OnWinConditionChanged_Postfix(InspectorPanel __instance)
		{
			if (KillEnemyCountEditorUi.IsKillEnemyCount(__instance))
			{
				WinConditionDescriptionText.Apply(__instance, WinConditionEditorUi.GetInspectedCondition(__instance));
				KillEnemyCountEditorUi.EnsureInspector(__instance);
			}
			else if (GetMultiKill(__instance) == null)
			{
				WinConditionEditorUi.EndMultiKillPickSession();
			}
			else
			{
				WinConditionEditorUi.EnsureMultiKillInspectorReady(__instance);
				RefreshDescription(__instance, (WinCondition)(object)GetMultiKill(__instance));
			}
		}

		public static void ShowApplyAndDeleteButton_Postfix(InspectorPanel __instance)
		{
			if (KillEnemyCountEditorUi.IsKillEnemyCount(__instance))
			{
				WinConditionDescriptionText.Apply(__instance, WinConditionEditorUi.GetInspectedCondition(__instance));
				KillEnemyCountEditorUi.EnsureInspector(__instance);
			}
			else if (GetMultiKill(__instance) != null)
			{
				WinConditionEditorUi.EnsureMultiKillInspectorReady(__instance);
			}
		}

		public static bool OnClickedReferenceButton_Prefix(UIReferenceField __instance)
		{
			if (!WinConditionEditorUi.IsMultiKillAddTargetField(__instance))
			{
				return true;
			}
			WinConditionEditorUi.BeginMultiKillUnitPick(__instance);
			return false;
		}

		public static bool UIReferenceField_UpdateUI_Prefix(UIReferenceField __instance)
		{
			if (!MultiKillTargetFieldUi.IsMultiKillField(__instance))
			{
				return true;
			}
			MustKillAllSelectedUnitsWinCondition multiKill = WinConditionEditorUi.GetMultiKill(((Component)__instance).GetComponentInParent<InspectorPanel>());
			if (multiKill == null)
			{
				return true;
			}
			if (PropertyOwnerProperty.GetValue(__instance, null) is MustKillAllSelectedUnitsWinCondition mustKillAllSelectedUnitsWinCondition && mustKillAllSelectedUnitsWinCondition != multiKill)
			{
				return true;
			}
			MultiKillTargetFieldUi.Refresh(__instance, multiKill);
			return false;
		}

		public static bool UIPropertyField_BindObject_Prefix(UIPropertyField __instance, object propertyOwner, FieldInfo propertyField)
		{
			if (AccessTools.Field(typeof(UIPropertyField), "m_WinconditionDisplayInspector")?.GetValue(__instance) != null || propertyField?.FieldType != typeof(int))
			{
				return true;
			}
			AccessTools.Property(typeof(UIPropertyField), "PropertyOwner")?.SetValue(__instance, propertyOwner, null);
			AccessTools.Property(typeof(UIPropertyField), "PropertyField")?.SetValue(__instance, propertyField, null);
			object obj = AccessTools.Field(typeof(UIPropertyField), "m_inputField")?.GetValue(__instance);
			if (obj == null)
			{
				return true;
			}
			MethodInfo methodInfo = AccessTools.Method(typeof(UIPropertyField), "OnPropertyChanged", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				UnityAction<string> val = (UnityAction<string>)(object)Delegate.CreateDelegate(typeof(UnityAction<string>), __instance, methodInfo);
				Traverse.Create(obj).Property("onValueChanged", (object[])null).GetValue<UnityEvent<string>>()?.AddListener(val);
			}
			object value = propertyField.GetValue(propertyOwner);
			obj.GetType().GetProperty("text")?.SetValue(obj, value?.ToString() ?? string.Empty, null);
			if (propertyOwner is KillEnemyCountWinCondition)
			{
				WinConditionFieldLabels.Force(__instance, "Kill this many enemy units");
			}
			return false;
		}

		public static bool ReferencePickFinished_Prefix(UIReferenceField __instance, RuntimeReference reference)
		{
			if (!WinConditionEditorUi.IsMultiKillAddTargetField(__instance))
			{
				return true;
			}
			WinConditionEditorUi.FinishReferencePick(__instance, reference);
			return false;
		}

		public static bool BackButtonActions_Prefix(InspectorPanel __instance)
		{
			if (GetMultiKill(__instance) == null)
			{
				return true;
			}
			((MonoBehaviour)__instance).StartCoroutine(WinConditionEditorUi.MultiKillBackRoutine(__instance));
			return false;
		}

		public static bool RemoveInspectedWinCondition_Prefix(InspectorPanel __instance)
		{
			if (!(BoundGuidField?.GetValue(__instance) is Guid guid) || guid == Guid.Empty)
			{
				return true;
			}
			object? obj = BoundItemField?.GetValue(__instance);
			UIListItem listItem = (UIListItem)((obj is UIListItem) ? obj : null);
			if (!WinConditionDeletion.DeleteBoundCondition(__instance, listItem))
			{
				return true;
			}
			return false;
		}

		public static bool CheckWinConditionExists_Prefix(InspectorPanel __instance, UIListItem conditionItem)
		{
			//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_0068: 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)
			if (!(((conditionItem != null) ? conditionItem.UserData : null) is Guid guid))
			{
				return true;
			}
			object? obj = WinConditionPropagatorField?.GetValue(__instance);
			WinConditionPropagator val = (WinConditionPropagator)((obj is WinConditionPropagator) ? obj : null);
			if (val == null || !(InspectorTeamField?.GetValue(__instance) is Team val2))
			{
				return true;
			}
			if (!(val.GetWinConditionFromTeam(val2, guid) is MustKillAllSelectedUnitsWinCondition mustKillAllSelectedUnitsWinCondition) || mustKillAllSelectedUnitsWinCondition.TargetCount > 0)
			{
				return true;
			}
			((WinCondition)mustKillAllSelectedUnitsWinCondition).OnRemovedFromgGUI();
			val.RemoveWinCondition(val2, (WinCondition)(object)mustKillAllSelectedUnitsWinCondition);
			MultiKillTargetRegistry.Rebuild(val);
			WinConditionEditorUi.RemoveListItem(__instance, conditionItem);
			return false;
		}

		public static bool ShowAfterUnitSelected_Prefix()
		{
			if (WinConditionEditorUi.IsMultiKillPickSessionActive)
			{
				return false;
			}
			return true;
		}

		public static void UpdateBackButtons_Postfix(object __instance)
		{
			WinConditionEditorUi.ApplyMultiKillBackButtonState(__instance);
		}

		public static bool WinConditionPresenter_OnUnitRemoved_Prefix(WinConditionPresenter __instance, Unit unit)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (((unit != null) ? unit.RuntimeReference : null) == null || !MultiKillTargetRegistry.IsTarget(((RuntimeReference)unit.RuntimeReference).Guid))
			{
				return true;
			}
			object? value = PresenterPropagatorField.GetValue(__instance);
			WinConditionPropagator val = (WinConditionPropagator)((value is WinConditionPropagator) ? value : null);
			if (val == null || !TryGetMultiKillForUnit(val, ((RuntimeReference)unit.RuntimeReference).Guid, out var condition))
			{
				return true;
			}
			if (!condition.RemoveTarget(((RuntimeReference)unit.RuntimeReference).Guid))
			{
				return true;
			}
			WinConditionUiRefresh.UpdateMultiKillDisplays(condition, WinConditionEditorUi.FindInspectorInspectingCondition((WinCondition)(object)condition));
			RefreshOpenMultiKillInspector(condition);
			if (condition.TargetCount == 0)
			{
				val.RemoveWinCondition(((WinCondition)condition).OwningTeam, (WinCondition)(object)condition);
				PresenterShowConditionsMethod?.Invoke(__instance, null);
			}
			return false;
		}

		private static void RefreshOpenMultiKillInspector(MustKillAllSelectedUnitsWinCondition condition)
		{
			InspectorPanel val = WinConditionEditorUi.FindInspectorInspectingCondition((WinCondition)(object)condition);
			if (!((Object)(object)val == (Object)null) && GetMultiKill(val) == condition && IsVictoryInspectorOpen(val))
			{
				RefreshDescription(val, (WinCondition)(object)condition);
				WinConditionUiRefresh.RefreshMultiKillEditor(condition, val);
			}
		}

		private static bool IsVictoryInspectorOpen(InspectorPanel panel)
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(InspectorPanel), "m_WinConditionsComponent");
			if ((object)fieldInfo == null || fieldInfo.GetValue(panel) == null)
			{
				return false;
			}
			return Traverse.Create(fieldInfo.GetValue(panel)).Property("VictoryConditionsPanelIsOpen", (object[])null).GetValue<bool>();
		}

		private static bool TryGetMultiKillForUnit(WinConditionPropagator propagator, Guid unitGuid, out MustKillAllSelectedUnitsWinCondition condition)
		{
			//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)
			condition = null;
			if (propagator == null)
			{
				return false;
			}
			Team[] array = (Team[])(object)new Team[2]
			{
				default(Team),
				(Team)1
			};
			foreach (Team val in array)
			{
				WinCondition[] winConditionsForTeam = propagator.GetWinConditionsForTeam(val);
				for (int j = 0; j < winConditionsForTeam.Length; j++)
				{
					if (winConditionsForTeam[j] is MustKillAllSelectedUnitsWinCondition mustKillAllSelectedUnitsWinCondition && mustKillAllSelectedUnitsWinCondition.ContainsTarget(unitGuid))
					{
						condition = mustKillAllSelectedUnitsWinCondition;
						return true;
					}
				}
			}
			return false;
		}

		public static void BaseGameMode_OnExitBattleState_Postfix(BaseGameMode __instance)
		{
			//IL_0029: 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)
			WinConditionPropagator val = ((__instance != null) ? __instance.WinConditionPropagator : null);
			if (val == null)
			{
				return;
			}
			MultiKillTargetRegistry.Rebuild(val);
			Team[] array = (Team[])(object)new Team[2]
			{
				default(Team),
				(Team)1
			};
			foreach (Team val2 in array)
			{
				WinCondition[] winConditionsForTeam = val.GetWinConditionsForTeam(val2);
				for (int j = 0; j < winConditionsForTeam.Length; j++)
				{
					if (winConditionsForTeam[j] is MustKillAllSelectedUnitsWinCondition mustKillAllSelectedUnitsWinCondition)
					{
						mustKillAllSelectedUnitsWinCondition.PrepareForPlacement();
					}
				}
			}
		}

		public static void SetInspectedCondition_Postfix(InspectorPanel __instance)
		{
			if (KillEnemyCountEditorUi.IsKillEnemyCount(__instance))
			{
				WinConditionDescriptionText.Apply(__instance, WinConditionEditorUi.GetInspectedCondition(__instance));
				KillEnemyCountEditorUi.EnsureInspector(__instance);
				return;
			}
			MustKillAllSelectedUnitsWinCondition multiKill = GetMultiKill(__instance);
			if (multiKill == null)
			{
				WinConditionEditorUi.EndMultiKillPickSession();
				return;
			}
			WinConditionEditorUi.EnsureMultiKillInspectorReady(__instance);
			WinConditionDescriptionText.Apply(__instance, (WinCondition)(object)multiKill);
			SyncMultiKillMapIcons(multiKill, __instance);
			MultiKillInspectorChrome.ApplyDeferred(__instance);
		}

		public static void FieldController_BindObject_Postfix(FieldController __instance, object obj)
		{
			InspectorPanel componentInParent = ((Component)__instance).GetComponentInParent<InspectorPanel>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return;
			}
			if (obj is KillEnemyCountWinCondition condition)
			{
				KillEnemyCountFieldUi.ConfigureFieldController(__instance, condition);
				KillEnemyCountEditorUi.EnsureInspector(componentInParent);
			}
			else
			{
				if (!(obj is MustKillAllSelectedUnitsWinCondition condition2))
				{
					return;
				}
				UIReferenceField[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<UIReferenceField>(true);
				foreach (UIReferenceField field in componentsInChildren)
				{
					if (MultiKillTargetFieldUi.IsMultiKillField(field))
					{
						MultiKillTargetFieldUi.Refresh(field, condition2);
					}
				}
				MultiKillInspectorChrome.ApplyDeferred(componentInParent);
			}
		}

		public static void CheckUnitReferenceIsValid_Postfix(Unit unit, ref bool __result)
		{
			if (!__result && ((unit != null) ? unit.RuntimeReference : null) != null && MultiKillTargetRegistry.HasTargets && MultiKillTargetRegistry.IsTarget(((RuntimeReference)unit.RuntimeReference).Guid))
			{
				__result = true;
			}
		}

		public static void ReferenceRenderer_OnDestroy_Postfix()
		{
			_cachedReferenceRenderer = null;
		}

		public static void WinConditionPropagator_AddWinCondition_Postfix(Team team, WinCondition winCondition)
		{
			if (winCondition is MustKillAllSelectedUnitsWinCondition condition)
			{
				MultiKillTargetRegistry.AddFromCondition(condition);
				MultiKillTargetIcons.RefreshCondition(GetReferenceRenderer(), condition);
				WinConditionUiRefresh.UpdateMultiKillDisplays(condition, null, refreshObjectives: true);
			}
		}

		public static void ApplyWinCondition_Postfix(InspectorPanel __instance)
		{
			//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)
			//IL_0090: 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)
			object? value = BoundItemField.GetValue(__instance);
			UIListItem val = (UIListItem)((value is UIListItem) ? value : null);
			if (val == null)
			{
				return;
			}
			object userData = val.UserData;
			if (!(userData is Guid))
			{
				return;
			}
			Guid guid = (Guid)userData;
			object? obj = AccessTools.Field(typeof(InspectorPanel), "m_winConditionPropagator")?.GetValue(__instance);
			WinConditionPropagator val2 = (WinConditionPropagator)((obj is WinConditionPropagator) ? obj : null);
			object obj2 = AccessTools.Field(typeof(InspectorPanel), "m_team")?.GetValue(__instance);
			if (val2 != null && obj2 is Team)
			{
				Team val3 = (Team)obj2;
				if (val2.GetWinConditionFromTeam(val3, guid) is MustKillAllSelectedUnitsWinCondition condition)
				{
					SyncMultiKillCondition(condition, __instance);
					WinConditionUiRefresh.RefreshObjectivesSidebars();
				}
				else if (val2.GetWinConditionFromTeam(val3, guid) is KillEnemyCountWinCondition)
				{
					WinConditionUiRefresh.RefreshObjectivesSidebars();
				}
			}
		}

		public static void IsUnitMustKill_Postfix(WinConditionEvaluator __instance, Unit unit, ref bool __result, ref WinCondition mustKillUnitWinCondition)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			if (__result || ((unit != null) ? unit.RuntimeReference : null) == null || !MultiKillTargetRegistry.IsTarget(((RuntimeReference)unit.RuntimeReference).Guid) || !(EvaluatorConditionsField?.GetValue(__instance) is IList list))
			{
				return;
			}
			Guid guid = ((RuntimeReference)unit.RuntimeReference).Guid;
			foreach (WinCondition item in list)
			{
				if (item is MustKillAllSelectedUnitsWinCondition mustKillAllSelectedUnitsWinCondition && mustKillAllSelectedUnitsWinCondition.ContainsTarget(guid))
				{
					mustKillUnitWinCondition = (WinCondition)(object)mustKillAllSelectedUnitsWinCondition;
					__result = true;
					break;
				}
			}
		}

		public static void GetUpdateConditionIcons_Postfix(WinCondition winCondition, InspectorPanel __instance, ref Sprite __result)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			if (!(winCondition is MustKillAllSelectedUnitsWinCondition) && !(winCondition is KillEnemyCountWinCondition))
			{
				return;
			}
			object value = Traverse.Create((object)__instance).Field("m_WinConditionIcons").GetValue();
			if (value != null)
			{
				MethodInfo method = value.GetType().GetMethod("GetImage", new Type[1] { value.GetType().GetNestedType("ConditionType") });
				if (method != null)
				{
					__result = (Sprite)method.Invoke(value, new object[1] { 2 });
				}
			}
		}

		public static void StartHighlightUnit_Postfix(WinConditionListController __instance, UIListItem item)
		{
			MustKillAllSelectedUnitsWinCondition listCondition = GetListCondition(__instance, item);
			if (listCondition != null)
			{
				HighlightTargets(listCondition, highlight: true);
			}
		}

		public static void EndHighlightUnit_Postfix(WinConditionListController __instance, UIListItem item)
		{
			MustKillAllSelectedUnitsWinCondition listCondition = GetListCondition(__instance, item);
			if (listCondition != null)
			{
				HighlightTargets(listCondition, highlight: false);
			}
		}

		private static MustKillAllSelectedUnitsWinCondition GetListCondition(WinConditionListController controller, UIListItem item)
		{
			if (item == null || item.UserData == null || !(item.UserData is Guid guid))
			{
				return null;
			}
			object? obj = AccessTools.Method(typeof(WinConditionListController), "GetItemCondition", (Type[])null, (Type[])null)?.Invoke(controller, new object[1] { guid });
			return ((obj is WinCondition) ? obj : null) as MustKillAllSelectedUnitsWinCondition;
		}

		private static void HighlightTargets(MustKillAllSelectedUnitsWinCondition condition, bool highlight)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			RuntimeReferenceService service = ServiceLocator.GetService<RuntimeReferenceService>();
			foreach (ReferenceRequest<Unit> target in condition.Targets)
			{
				if (target == null)
				{
					continue;
				}
				Unit referenceTarget = service.GetReferenceTarget<Unit>((RuntimeReference)(object)target);
				if (!((Object)(object)referenceTarget == (Object)null))
				{
					if (highlight)
					{
						referenceTarget.SetHighlight(Color.white);
					}
					else
					{
						referenceTarget.RemoveHighlight();
					}
				}
			}
		}
	}
	internal static class WinConditionUiRefresh
	{
		private static readonly MethodInfo ClearObjectivesMethod = AccessTools.Method(typeof(WinConObjectivesUI), "ClearShownConditions", (Type[])null, (Type[])null);

		private static readonly MethodInfo ExtractObjectivesMethod = AccessTools.Method(typeof(WinConObjectivesUI), "ExtractWinConditions", (Type[])null, (Type[])null);

		private static readonly FieldInfo InspectorTeamListField = AccessTools.Field(typeof(InspectorPanel), "m_teamList");

		private static readonly FieldInfo BoundItemField = AccessTools.Field(typeof(InspectorPanel), "m_boundItem");

		private static readonly FieldInfo ListControllerUiListField = AccessTools.Field(typeof(WinConditionListController), "m_uiList");

		private static readonly FieldInfo InspectedConditionField = AccessTools.Field(typeof(InspectorPanel), "m_currentlyInspectedCondition");

		private static readonly FieldInfo FieldControllerField = AccessTools.Field(typeof(InspectorPanel), "m_fieldController");

		public static void RefreshMultiKillEditor(MustKillAllSelectedUnitsWinCondition condition, InspectorPanel panel = null)
		{
			if (condition == null)
			{
				return;
			}
			UpdateMultiKillDisplays(condition, panel);
			if ((Object)(object)panel != (Object)null && InspectedConditionField?.GetValue(panel) == condition)
			{
				WinConditionDescriptionText.Apply(panel, (WinCondition)(object)condition);
				object? obj = FieldControllerField?.GetValue(panel);
				FieldController val = (FieldController)((obj is FieldController) ? obj : null);
				if (val != null)
				{
					val.UpdateContentHeight();
				}
			}
			MultiKillTargetFieldUi.RefreshAllFields(condition, panel);
		}

		public static void UpdateMultiKillDisplays(MustKillAllSelectedUnitsWinCondition condition, InspectorPanel panel = null, bool refreshObjectives = false)
		{
			if (condition != null)
			{
				string[] args = default(string[]);
				string descriptionForListItem = ((WinCondition)condition).GetDescriptionForListItem(ref args);
				ApplyListText(((WinCondition)condition).Guid, descriptionForListItem, args, panel);
				if (refreshObjectives)
				{
					RefreshObjectivesSidebars();
				}
			}
		}

		private static void ApplyListText(Guid conditionGuid, string localeId, string[] args, InspectorPanel panel = null)
		{
			if ((Object)(object)panel != (Object)null)
			{
				ApplyListTextForPanel(panel, conditionGuid, localeId, args);
				return;
			}
			foreach (InspectorPanel allInspectorPanel in WinConditionEditorUi.GetAllInspectorPanels())
			{
				ApplyListTextForPanel(allInspectorPanel, conditionGuid, localeId, args);
			}
			WinConditionListController[] array = Object.FindObjectsOfType<WinConditionListController>();
			foreach (WinConditionListController obj in array)
			{
				object? value = ListControllerUiListField.GetValue(obj);
				UIList val = (UIList)((value is UIList) ? value : null);
				if (val == null || val.Items == null)
				{
					continue;
				}
				foreach (UIListItem item in val.Items)
				{
					if (((item != null) ? item.UserData : null) is Guid guid && guid == conditionGuid)
					{
						item.SetDisplayText(localeId, args);
					}
				}
			}
		}

		private static void ApplyListTextForPanel(InspectorPanel panel, Guid conditionGuid, string localeId, string[] args)
		{
			if ((Object)(object)panel == (Object)null)
			{
				return;
			}
			object? value = BoundItemField.GetValue(panel);
			UIListItem val = (UIListItem)((value is UIListItem) ? value : null);
			if (val != null && val.UserData is Guid guid && guid == conditionGuid)
			{
				val.SetDisplayText(localeId, args);
			}
			object? value2 = InspectorTeamListField.GetValue(panel);
			UIList val2 = (UIList)((value2 is UIList) ? value2 : null);
			if (val2 == null || val2.Items == null)
			{
				return;
			}
			foreach (UIListItem item in val2.Items)
			{
				if (((item != null) ? item.UserData : null) is Guid guid2 && guid2 == conditionGuid)
				{
					item.SetDisplayText(localeId, args);
				}
			}
		}

		public static void RefreshObjectivesSidebars()
		{
			WinConObjectivesUI[] array = Object.FindObjectsOfType<WinConObjectivesUI>();
			for (int i = 0; i < array.Length; i++)
			{
				ForceRebuildObjectives(array[i]);
			}
		}

		private static void ForceRebuildObjectives(WinConObjectivesUI objectivesUi)
		{
			if (!((Object)(object)objectivesUi == (Object)null) && !(ClearObjectivesMethod == null) && !(ExtractObjectivesMethod == null))
			{
				ClearObjectivesMethod.Invoke(objectivesUi, null);
				ExtractObjectivesMethod.Invoke(objectivesUi, null);
			}
		}
	}
}
namespace TabsUnlimited.TeamLine
{
	internal static class ModEdgeTypes
	{
		public const int SquareValue = 2;

		public static EdgeType Square => (EdgeType)2;

		public static bool IsSquare(EdgeType edgeType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			return (int)edgeType == 2;
		}

		public static EdgeType Next(EdgeType current)
		{
			//IL_0000: 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_0007: Invalid comparison between Unknown and I4
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if ((int)current == 0)
			{
				return (EdgeType)1;
			}
			if ((int)current == 1)
			{
				return Square;
			}
			return (EdgeType)0;
		}

		public static string GetDisplayName(EdgeType edgeType)
		{
			//IL_0000: 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_000b: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if ((int)edgeType == 0)
			{
				return "Line";
			}
			if ((int)edgeType == 1)
			{
				return "Circle";
			}
			if (IsSquare(edgeType))
			{
				return "Square";
			}
			return ((object)(EdgeType)(ref edgeType)).ToString();
		}
	}
	internal static class TeamLineSquareAssets
	{
		[CompilerGenerated]
		private sealed class <EnumerateCandidateBundles>d__16 : IEnumerable<AssetBundle>, IEnumerable, IEnumerator<AssetBundle>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private AssetBundle <>2__current;

			private int <>l__initialThreadId;

			private IEnumerator<AssetBundle> <>7__wrap1;

			private IEnumerator<string> <>7__wrap2;

			AssetBundle IEnumerator<AssetBundle>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EnumerateCandidateBundles>d__16(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 3:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<>7__wrap1 = null;
				<>7__wrap2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = TeamLineSquareBundlePreloader.GetPreloaded().GetEnumerator();
						<>1__state = -3;
						goto IL_0077;
					case 1:
						<>1__state = -3;
						goto IL_0077;
					case 2:
						<>1__state = -1;
						result = false;
						break;
					case 3:
						{
							<>1__state = -4;
							result = false;
							<>m__Finally2();
							break;
						}
						IL_0077:
						while (true)
						{
							if (<>7__wrap1.MoveNext())
							{
								AssetBundle current = <>7__wrap1.Current;
								if ((Object)(object)current != (Object)null)
								{
									<>2__current = current;
									<>1__state = 1;
									result = true;
									break;
								}
								continue;
							}
							<>m__Finally1();
							<>7__wrap1 = null;
							if ((Object)(object)_loadedBundle != (Object)null)
							{
								<>2__current = _loadedBundle;
								<>1__state = 2;
								result = true;
								break;
							}
							<>7__wrap2 = GetCandidateBundlePaths().GetEnumerator();
							<>1__state = -4;
							while (true)
							{
								if (<>7__wrap2.MoveNext())
								{
									string current2 = <>7__wrap2.Current;
									if (File.Exists(current2))
									{
										_loadedBundle = TeamLineSquareBundlePreloader.LoadOnce(current2);
										if (!((Object)(object)_loadedBundle == (Object)null))
										{
											Plugin.LogInfo("Square team line: loaded asset bundle '" + Path.GetFileName(current2) + "'");
											<>2__current = _loadedBundle;
											<>1__state = 3;
											result = true;
											break;
										}
										if (!_loggedBundleNull)
										{
											_loggedBundleNull = true;
											Plugin.LogWarning("Square team line: asset bundle LoadFromFile returned null for '" + Path.GetFileName(current2) + "'");
										}
									}
									continue;
								}
								<>m__Finally2();
								<>7__wrap2 = null;
								result = false;
								break;
							}
							break;
						}
						break;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

			private void <>m__Finally2()
			{
				<>1__state = -1;
				if (<>7__wrap2 != null)
				{
					<>7__wrap2.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<AssetBundle> IEnumerable<AssetBundle>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <EnumerateCandidateBundles>d__16(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<AssetBundle>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetCandidateBundlePaths>d__17 : IEnumerable<string>, IEnumerable, IEnumerator<string>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string <dir>5__2;

			string IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetCandidateBundlePaths>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<dir>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<dir>5__2 = GetPluginDirectory();
					if (string.IsNullOrEmpty(<dir>5__2))
					{
						return false;
					}
					<>2__current = Path.Combine(<dir>5__2, "teamedge_square.assetbundle");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = Path.Combine(<dir>5__2, "teamedge_square");
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<string> IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetCandidateBundlePaths>d__17(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<string>)this).GetEnumerator();
			}
		}

		private const string BundleBaseName = "teamedge_square";

		private const string BundleFileNameWithExtension = "teamedge_square.assetbundle";

		private const string MaterialAssetName = "TeamEdgeSquareBundleMaterial";

		private const string ShaderName = "Hidden/StayCombatFix/TeamEdgeSquare";

		private static bool _loadAttempted;

		private static bool _loggedMissing;

		private static bool _loggedBundleNull;

		private static Shader _squareShader;

		private static AssetBundle _loadedBundle;

		internal static Shader SquareShader
		{
			get
			{
				EnsureLoaded();
				return _squareShader;
			}
		}

		internal static bool HasSquareShader
		{
			get
			{
				EnsureLoaded();
				return (Object)(object)_squareShader != (Object)null;
			}
		}

		internal static void TryLoad()
		{
			EnsureLoaded();
		}

		private static void EnsureLoaded()
		{
			if (!((Object)(object)_squareShader != (Object)null) && !_loadAttempted)
			{
				_loadAttempted = true;
				_squareShader = LoadFromBundleOnce();
				if (!((Object)(object)_squareShader != (Object)null) && !_loggedMissing)
				{
					_loggedMissing = true;
					Plugin.LogWarning("Square team line: teamedge_square.assetbundle missing or invalid. Square mode will use circle fallback.");
				}
			}
		}

		private static Shader LoadFromBundleOnce()
		{
			foreach (AssetBundle item in EnumerateCandidateBundles())
			{
				Shader val = ExtractShaderFromBundle(item);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		[IteratorStateMachine(typeof(<EnumerateCandidateBundles>d__16))]
		private static IEnumerable<AssetBundle> EnumerateCandidateBundles()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumerateCandidateBundles>d__16(-2);
		}

		[IteratorStateMachine(typeof(<GetCandidateBundlePaths>d__17))]
		private static IEnumerable<string> GetCandidateBundlePaths()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetCandidateBundlePaths>d__17(-2);
		}

		private static Shader ExtractShaderFromBundle(AssetBundle bundle)
		{
			if ((Object)(object)bundle == (Object)null)
			{
				return null;
			}
			ShaderVariantCollection[] array = bundle.LoadAllAssets<ShaderVariantCollection>();
			foreach (ShaderVariantCollection val in array)
			{
				if (!((Object)(object)val == (Object)null) && !val.isWarmedUp)
				{
					val.WarmUp();
				}
			}
			Material val2 = bundle.LoadAsset<Material>("TeamEdgeSquareBundleMaterial") ?? ((IEnumerable<Material>)bundle.LoadAllAssets<Material>()).FirstOrDefault((Func<Material, bool>)((Material m) => (Object)(object)m != (Object)null && (Object)(object)m.shader != (Object)null && ((Object)m.shader).name == "Hidden/StayCombatFix/TeamEdgeSquare"));
			if ((Object)(object)val2 != (Object)null && (Object)(object)val2.shader != (Object)null && ((Object)val2.shader).name == "Hidden/StayCombatFix/TeamEdgeSquare")
			{
				Plugin.LogInfo("Square team line: loaded TeamEdgeSquare shader from asset bundle (material)");
				return val2.shader;
			}
			Shader val3 = ((IEnumerable<Shader>)bundle.LoadAllAssets<Shader>()).FirstOrDefault((Func<Shader, bool>)((Shader s) => (Object)(object)s != (Object)null && ((Object)s).name == "Hidden/StayCombatFix/TeamEdgeSquare"));
			if ((Object)(object)val3 != (Object)null)
			{
				Plugin.LogInfo("Square team line: loaded TeamEdgeSquare shader from asset bundle");
				return val3;
			}
			return null;
		}

		private static string GetPluginDirectory()
		{
			string location = Assembly.GetExecutingAssembly().Location;
			string text;
			if (!string.IsNullOrEmpty(location))
			{
				text = Path.GetDirectoryName(location);
				if (text == null)
				{
					return string.Empty;
				}
			}
			else
			{
				text = string.Empty;
			}
			return text;
		}
	}
	internal static class TeamLineSquareBorderRender
	{
		private static bool _initialized;

		private static bool _loggedCircleFallback;

		private static bool _loggedSheetFailed;

		private static MethodInfo _renderEdgeMethod;

		private static EdgeType? _edgeTypeRestore;

		internal static bool TryRegister(Harmony harmony, ref int applied)
		{
			//IL_0029: 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_004b: Expected O, but got Unknown
			//IL_004b: Expected O, but got Unknown
			if (!Initialize())
			{
				Plugin.LogWarning("Square team line render: could not patch TeamEdgeRenderer.RenderEdge");
				return false;
			}
			harmony.Patch((MethodBase)_renderEdgeMethod, new HarmonyMethod(typeof(TeamLineSquareBorderRender), "RenderEdge_Prefix", (Type[])null), new HarmonyMethod(typeof(TeamLineSquareBorderRender), "RenderEdge_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			applied++;
			Plugin.LogInfo("Square team line render: RenderEdge hook registered");
			return true;
		}

		private static bool Initialize()
		{
			if (_initialized)
			{
				return _renderEdgeMethod != null;
			}
			_initialized = true;
			try
			{
				Type type = AccessTools.TypeByName("Landfall.TABS.TeamEdge.TeamEdgeRenderer, Assembly-CSharp");
				Type type2 = AccessTools.TypeByName("UnityEngine.Rendering.PostProcessing.PostProcessRenderContext, Unity.Postprocessing.Runtime");
				if (type == null || type2 == null)
				{
					return false;
				}
				_renderEdgeMethod = AccessTools.DeclaredMethod(type, "RenderEdge", new Type[1] { type2 }, (Type[])null);
				return _renderEdgeMethod != null;
			}
			catch (Exception ex)
			{
				Plugin.LogWarning("Square team line render init failed: " + ex.Message);
				return false;
			}
		}

		internal static void RenderEdge_Prefix()
		{
			//IL_002c: 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)
			if (ShouldDraw() && !TeamLineSquareAssets.HasSquareShader)
			{
				if (!_loggedCircleFallback)
				{
					_loggedCircleFallback = true;
					Plugin.LogWarning("Square team line: shader bundle missing — using circle tint fallback (no black-screen composite).");
				}
				_edgeTypeRestore = SceneSettings.Instance.m_EdgeType;
				SceneSettings.Instance.m_EdgeType = (EdgeType)1;
			}
		}

		internal static void RenderEdge_Postfix(object __instance, object context, ref object __result)
		{
			//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_0066: 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_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 (_edgeTypeRestore.HasValue)
			{
				SceneSettings.Instance.m_EdgeType = _edgeTypeRestore.Value;
				_edgeTypeRestore = null;
			}
			else
			{
				if (!ShouldDraw() || !TeamLineSquareAssets.HasSquareShader)
				{
					return;
				}
				object obj = TeamLineSquareShaderApply.TryBuildSquareSheet(__instance, context);
				if (obj != null)
				{
					__result = obj;
					return;
				}
				if (!_loggedSheetFailed)
				{
					_loggedSheetFailed = true;
					Plugin.LogWarning("Square team line: could not build property sheet — using circle tint for this frame.");
				}
				_edgeTypeRestore = SceneSettings.Instance.m_EdgeType;
				SceneSettings.Instance.m_EdgeType = (EdgeType)1;
				__result = _renderEdgeMethod.Invoke(__instance, new object[1] { context });
				SceneSettings.Instance.m_EdgeType = _edgeTypeRestore.Value;
				_edgeTypeRestore = null;
			}
		}

		private static bool ShouldDraw()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (!Application.isPlaying || (Object)(object)SceneSettings.Instance == (Object)null)
			{
				return false;
			}
			if (!ModEdgeTypes.IsSquare(SceneSettings.Instance.m_EdgeType))
			{
				return false;
			}
			if (!SceneSettings.UseNewPlacementSystem)
			{
				return false;
			}
			if ((int)ServiceLocator.GetService<GameStateManager>().GameState != 0)
			{
				return false;
			}
			if (SandboxPlacementCamera.InFreeLook)
			{
				return false;
			}
			return true;
		}
	}
	internal static class TeamLineSquareBundlePreloader
	{
		private static readonly List<AssetBundle> Preloaded = new List<AssetBundle>();

		private static readonly HashSet<string> AttemptedPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static void PreloadFromPluginDirectory()
		{
			string pluginDirectory = GetPluginDirectory();
			if (string.IsNullOrEmpty(pluginDirectory) || !Directory.Exists(pluginDirectory))
			{
				return;
			}
			foreach (string item in Directory.EnumerateFiles(pluginDirectory, "*.assetbundle"))
			{
				AttemptLoad(item);
			}
		}

		internal static AssetBundle LoadOnce(string path)
		{
			if (string.IsNullOrEmpty(path) || !File.Exists(path))
			{
				return null;
			}
			return AttemptLoad(path);
		}

		internal static bool WasAttempted(string path)
		{
			if (!string.IsNullOrEmpty(path))
			{
				return AttemptedPaths.Contains(Path.GetFullPath(path));
			}
			return false;
		}

		internal static IReadOnlyList<AssetBundle> GetPreloaded()
		{
			return Preloaded;
		}

		private static AssetBundle AttemptLoad(string path)
		{
			string fullPath = Path.GetFullPath(path);
			if (!AttemptedPaths.Add(fullPath))
			{
				return null;
			}
			AssetBundle val = AssetBundle.LoadFromFile(fullPath);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Preloaded.Add(val);
			Plugin.LogInfo("Square team line: preloaded asset bundle '" + Path.GetFileName(fullPath) + "'");
			return val;
		}

		private static string GetPluginDirectory()
		{
			string location = Assembly.GetExecutingAssembly().Location;
			string text;
			if (!string.IsNullOrEmpty(location))
			{
				text = Path.GetDirectoryName(location);
				if (text == null)
				{
					return string.Empty;
				}
			}
			else
			{
				text = string.Empty;
			}
			return text;
		}
	}
	internal static class TeamLineSquareCameraPatches
	{
		private static bool _blockedSandboxCamera;

		private static MethodInfo _setBlockCameraMovement;

		internal static bool TryRegister(Harmony harmony, ref int applied)
		{
			//IL_0047: 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_0069: Expected O, but got Unknown
			//IL_0069: Expected O, but got Unknown
			Type type = FindPlacementCameraMovementType();
			MethodInfo methodInfo = ((type != null) ? AccessTools.Method(type, "MoveUpdate", (Type[])null, (Type[])null) : null);
			if (methodInfo == null)
			{
				Plugin.LogWarning("Square camera patches: PlacementCameraMovement.MoveUpdate not found");
				return false;
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(TeamLineSquareCameraPatches), "PlacementCameraMovement_MoveUpdate_Prefix", (Type[])null), new HarmonyMethod(typeof(TeamLineSquareCameraPatches), "PlacementCameraMovement_MoveUpdate_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			applied++;
			Type type2 = AccessTools.TypeByName("UIScreenInputBlocker, Assembly-CSharp");
			_setBlockCameraMovement = ((type2 != null) ? AccessTools.Method(type2, "SetBlockCameraMovement", (Type[])null, (Type[])null) : null);
			if (_setBlockCameraMovement == null)
			{
				Plugin.LogWarning("Square camera patches: UIScreenInputBlocker.SetBlockCameraMovement not found");
			}
			return true;
		}

		internal static void ForceUnblockSandboxCamera()
		{
			if (!(_setBlockCameraMovement == null) && _blockedSandboxCamera)
			{
				_setBlockCameraMovement.Invoke(null, new object[1] { false });
				_blockedSandboxCamera = false;
			}
		}

		internal static void UpdateSandboxCameraBlock()
		{
			if (!(_setBlockCameraMovement == null))
			{
				if (IsSquareLineSizingWithModifier())
				{
					_setBlockCameraMovement.Invoke(null, new object[1] { true });
					_blockedSandboxCamera = true;
				}
				else if (_blockedSandboxCamera)
				{
					_setBlockCameraMovement.Invoke(null, new object[1] { false });
					_blockedSandboxCamera = false;
				}
			}
		}

		internal static bool IsSquareLineSizingWithModifier()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (!Application.isPlaying)
			{
				return false;
			}
			SceneSettings instance = SceneSettings.Instance;
			if ((Object)(object)instance == (Object)null || !ModEdgeTypes.IsSquare(instance.m_EdgeType) || !SceneSettings.IsEditingLine)
			{
				return false;
			}
			if (!IsShiftHeld())
			{
				return IsCtrlHeld();
			}
			return true;
		}

		private static bool IsShiftHeld()
		{
			if (!Input.GetKey((KeyCode)304))
			{
				return Input.GetKey((KeyCode)303);
			}
			return true;
		}

		private static bool IsCtrlHeld()
		{
			if (!Input.GetKey((KeyCode)306))
			{
				return Input.GetKey((KeyCode)305);
			}
			return true;
		}

		internal static void PlacementCameraMovement_MoveUpdate_Postfix(object __instance)
		{
			//IL_0059: 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_008d: 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_0097: 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_00be: 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_00cb: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			if (TABSSceneManager.IsInUnitCreatorScene() || !IsSquareLineSizingWithModifier())
			{
				return;
			}
			CameraMovement value = Traverse.Create(__instance).Field<CameraMovement>("m_cameraMovement").Value;
			if ((Object)(object)value == (Object)null)
			{
				return;
			}
			EventSystem value2 = Traverse.Create(__instance).Field<EventSystem>("eventSystem").Value;
			if (!((Object)(object)value2 != (Object)null) || !value2.IsPointerOverGameObject())
			{
				Transform transform = ((Component)__instance).transform;
				float num = Mathf.Clamp(Time.unscaledDeltaTime, 0f, 0.1f);
				if (IsCtrlHeld())
				{
					value.Velocity += Vector3.up * num;
				}
				float axis = Input.GetAxis("Mouse ScrollWheel");
				if (Mathf.Abs(axis) > 0.0001f)
				{
					value.Velocity -= transform.forward * axis * num * 100f;
				}
			}
		}

		private static bool PlacementCameraMovement_MoveUpdate_Prefix()
		{
			if (TABSSceneManager.IsInUnitCreatorScene())
			{
				return false;
			}
			return true;
		}

		private static Type FindPlacementCameraMovementType()
		{
			return typeof(SceneSettings).Assembly.GetTypes().FirstOrDefault((Type t) => t.Name == "PlacementCameraMovement");
		}
	}
	internal static class TeamLineSquareDimensions
	{
		private static readonly FieldInfo SizeField = AccessTools.Field(typeof(SceneSettings), "m_size");

		internal const float DefaultHalfExtent = 20f;

		private static float _halfDepth = -1f;

		internal static float HalfWidth(SceneSettings settings)
		{
			return Mathf.Max(settings.m_CircleRadius, 0.1f);
		}

		internal static float HalfDepth(SceneSettings settings)
		{
			if (_halfDepth < 0f)
			{
				_halfDepth = HalfWidth(settings);
			}
			return Mathf.Max(_halfDepth, 0.1f);
		}

		internal static void SetHalfDepth(float value)
		{
			_halfDepth = Mathf.Clamp(value, 2f, 10000f);
		}

		internal static void ResetForEdit(SceneSettings settings)
		{
			_halfDepth = HalfWidth(settings);
		}

		internal static void ResetSquareSizeAndDepth(SceneSettings settings)
		{
			settings.m_CircleRadius = 20f;
			SizeField?.SetValue(settings, 20f);
			_halfDepth = 20f;
		}
	}
	internal static class TeamLineSquareDropdown
	{
		private const string SquareLabel = "Square";

		private static readonly FieldInfo DropdownField = AccessTools.Field(typeof(MapSettingsUI), "dropdown");

		private static bool _optionAdded;

		internal static void EnsureSquareOption(MapSettingsUI ui)
		{
			if (_optionAdded || (Object)(object)ui == (Object)null)
			{
				return;
			}
			object value = DropdownField.GetValue(ui);
			if (value == null)
			{
				return;
			}
			try
			{
				object options = GetOptions(value);
				if (options != null)
				{
					if (OptionCount(options) >= 3)
					{
						_optionAdded = true;
						return;
					}
					AddOption(options, "Square");
					SetOptions(value, options);
					_optionAdded = true;
				}
			}
			catch (Exception ex)
			{
				Plugin.LogWarning("Square line dropdown: " + ex.Message);
			}
		}

		internal static void SyncValue(MapSettingsUI ui)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected I4, but got Unknown
			if ((Object)(object)ui == (Object)null)
			{
				return;
			}
			object value = DropdownField.GetValue(ui);
			if (value == null)
			{
				return;
			}
			SceneSettings instance = SceneSettings.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				int num = (int)instance.m_EdgeType;
				if (num < 0 || num > 2)
				{
					num = 0;
				}
				SetDropdownValue(value, num);
			}
		}

		private static object GetOptions(object dropdown)
		{
			return dropdown.GetType().GetProperty("options")?.GetValue(dropdown);
		}

		private static void SetOptions(object dropdown, object options)
		{
			dropdown.GetType().GetProperty("options")?.SetValue(dropdown, options);
		}

		private static int OptionCount(object options)
		{
			if (options is ICollection collection)
			{
				return collection.Count;
			}
			PropertyInfo property = options.GetType().GetProperty("Count");
			if (!(property != null))
			{
				return 0;
			}
			return (int)property.GetValue(options);
		}

		private static void AddOption(object options, string label)
		{
			if (options is IList list)
			{
				Type obj = list.GetType().GetGenericArguments()[0];
				object obj2 = Activator.CreateInstance(obj);
				obj.GetField("text", BindingFlags.Instance | BindingFlags.Public)?.SetValue(obj2, label);
				list.Add(obj2);
			}
		}

		private static void SetDropdownValue(object dropdown, int value)
		{
			dropdown.GetType().GetProperty("value")?.SetValue(dropdown, value);
		}
	}
	internal static class TeamLineSquareEditing
	{
		private const float MouseWheelRotationSpeed = 60f;

		private static readonly FieldInfo IsEditingLineField = AccessTools.Field(typeof(SceneSettings), "isEditingLine");

		private static readonly FieldInfo UnitBrushField = AccessTools.Field(typeof(SceneSettings), "unitBrush");

		private static readonly FieldInfo PlayerActionsField = AccessTools.Field(typeof(SceneSettings), "m_playerActions");

		private static readonly FieldInfo PlacementLineCursorField = AccessTools.Field(typeof(SceneSettings), "placementLineCursor");

		private static readonly FieldInfo RotField = AccessTools.Field(typeof(SceneSettings), "m_rot");

		private static readonly FieldInfo SizeField = AccessTools.Field(typeof(SceneSettings), "m_size");

		private static readonly FieldInfo PosField = AccessTools.Field(typeof(SceneSettings), "m_pos");

		private static readonly FieldInfo OffsetField = AccessTools.Field(typeof(SceneSettings), "offset");

		internal static void Apply(SceneSettings settings)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//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_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_008f: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			if (!(bool)IsEditingLineField.GetValue(settings))
			{
				return;
			}
			PlayerActions val = (PlayerActions)PlayerActionsField.GetValue(settings);
			object value = UnitBrushField.GetValue(settings);
			MethodInfo raycastMap = value?.GetType().GetMethod("RaycastMap");
			float num = (float)RotField.GetValue(settings);
			float num2 = (float)SizeField.GetValue(settings);
			Vector3 val2 = (Vector3)PosField.GetValue(settings);
			Vector3 val3 = (Vector3)OffsetField.GetValue(settings);
			float num3 = (((int)val.InputType == 0) ? 0.01f : 1f);
			float num4 = ((OneAxisInputControl)val.m_placementZoom).Value * num3;
			Vector3 position = default(Vector3);
			if (Input.GetMouseButton(1) && TryRaycastMap(raycastMap, value, out position))
			{
				Vector3 val4 = position;
				val4.y = 0f;
				Vector3 val5 = val3;
				val5.y = 0f;
				Vector3 val6 = val4 - val5;
				if (((Vector3)(ref val6)).sqrMagnitude > 4f)
				{
					((Vector3)(ref val6)).Normalize();
					num = (0f - Mathf.Atan2(val6.z, val6.x)) * 57.29578f;
				}
			}
			else
			{
				if (((OneAxisInputControl)val.m_finishEditLine).WasPressed)
				{
					settings.StopLineEditing();
					return;
				}
				if (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303))
				{
					num2 += num4 * Mathf.Pow(Mathf.Max(num2, 2f), 0.5f) * (float)Math.PI;
					num2 = Mathf.Clamp(num2, 2f, 10000f);
				}
				else if (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305))
				{
					float num5 = TeamLineSquareDimensions.HalfDepth(settings);
					num5 += num4 * Mathf.Pow(Mathf.Max(num5, 2f), 0.5f) * (float)Math.PI;
					TeamLineSquareDimensions.SetHalfDepth(num5);
				}
				else
				{
					num += num4 * 60f;
				}
				if (TryRaycastMap(raycastMap, value, out var position2))
				{
					val2 = position2;
				}
				val3 = Vector3.Lerp(val3, val2, Time.deltaTime * 10f);
				PlacementLineCursor val7 = (PlacementLineCursor)PlacementLineCursorField.GetValue(settings);
				if ((Object)(object)val7 != (Object)null)
				{
					((Component)val7).transform.position = val3;
				}
			}
			RotField.SetValue(settings, num);
			SizeField.SetValue(settings, num2);
			PosField.SetValue(settings, val2);
			OffsetField.SetValue(settings, val3);
			Quaternion val8 = Quaternion.Lerp(Quaternion.Euler(0f, settings.m_Rotation, 0f), Quaternion.Euler(0f, num, 0f), Time.deltaTime * 10f);
			float y = ((Quaternion)(ref val8)).eulerAngles.y;
			settings.m_Rotation = y;
			settings.m_CircleRadius = Mathf.Lerp(settings.m_CircleRadius, num2, Time.deltaTime * 10f);
			TeamLineSquareCameraPatches.UpdateSandboxCameraBlock();
		}

		private static bool TryRaycastMap(MethodInfo raycastMap, object unitBrush, out Vector3 position)
		{
			//IL_0001: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			position = default(Vector3);
			if (raycastMap == null || unitBrush == null)
			{
				return false;
			}
			object[] array = new object[1] { position };
			bool result = (bool)raycastMap.Invoke(unitBrush, array);
			position = (Vector3)array[0];
			return result;
		}
	}
	internal static class TeamLineSquareHelpText
	{
		internal static string Keyboard => "Scroll: rotate" + Environment.NewLine + "Shift+scroll: size" + Environment.NewLine + "Ctrl+scroll: depth" + Environment.NewLine + "Left click: confirm";

		internal static string Controller => "Triggers: rotate" + Environment.NewLine + "Shift+scroll: size" + Environment.NewLine + "Ctrl+scroll: depth" + Environment.NewLine + "Confirm: finish";
	}
	internal static class TeamLineSquareHelpUi
	{
		private const float HelpFontSizeMax = 14f;

		private const float HelpFontSizeMin = 10f;

		private static readonly FieldInfo MapSettingsUiHelpText = AccessTools.Field(typeof(MapSettingsUI), "helpText");

		private static readonly FieldInfo MapSettingsComponentHelpText = AccessTools.Field(typeof(MapSettingsComponent), "helpText");

		internal static void ApplyToMapSettingsUi(MapSettingsUI ui)
		{
			RefreshAndStyle(MapSettingsUiHelpText.GetValue(ui));
		}

		internal static void ApplyToMapSettingsComponent(MapSettingsComponent component)
		{
			RefreshAndStyle(MapSettingsComponentHelpText.GetValue(component));
		}

		private static bool IsSquareActive()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			SceneSettings instance = SceneSettings.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				return ModEdgeTypes.IsSquare(instance.m_EdgeType);
			}
			return false;
		}

		private static void RefreshAndStyle(object helpText)
		{
			if (IsSquareActive() && helpText != null)
			{
				string value = (UsesControllerHelp() ? TeamLineSquareHelpText.Controller : TeamLineSquareHelpText.Keyboard);
				helpText.GetType().GetProperty("text")?.SetValue(helpText, value, null);
				ApplyFontSettings(helpText);
			}
		}

		private static bool UsesControllerHelp()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			PlayerActions instance = PlayerActions.Instance;
			if (instance != null)
			{
				return (int)instance.InputType == 0;
			}
			return false;
		}

		private static void ApplyFontSettings(object helpText)
		{
			Type type = helpText.GetType();
			type.GetProperty("enableAutoSizing")?.SetValue(helpText, true, null);
			type.GetProperty("fontSizeMin")?.SetValue(helpText, 10f, null);
			type.GetProperty("fontSizeMax")?.SetValue(helpText, 14f, null);
			type.GetProperty("fontSize")?.SetValue(helpText, 14f, null);
			PropertyInfo property = type.GetProperty("overflowMode");
			if (property != null)
			{
				object value = Enum.Parse(property.PropertyType, "Overflow");
				property.SetValue(helpText, value, null);
			}
		}
	}
	internal static class TeamLineSquareLogic
	{
		internal static TeamRequestReslut GetTeamTerritory(SceneSettings settings, Vector3 point, out Quaternion rotation)
		{
			//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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_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_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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_006f: 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_0095: 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_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)
			//IL_00a0: 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_008e: 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)
			Vector3 lineCenter = settings.LineCenter;
			float halfWidth = TeamLineSquareDimensions.HalfWidth(settings);
			float halfDepth = TeamLineSquareDimensions.HalfDepth(settings);
			Vector2 point2 = default(Vector2);
			((Vector2)(ref point2))..ctor(point.x, point.z);
			Vector2 center = default(Vector2);
			((Vector2)(ref center))..ctor(lineCenter.x, lineCenter.z);
			float rotation2 = settings.m_Rotation;
			bool num = IsInsideSquare(point2, center, rotation2, halfWidth, halfDepth);
			Vector3 val = (num ? FacingOutwardInside(point2, center, rotation2, halfWidth, halfDepth) : FacingInwardFromClosestEdge(point2, center, rotation2, halfWidth, halfDepth));
			rotation = Quaternion.LookRotation(val);
			if (!num)
			{
				Team val2 = (Team)0;
				if (settings.m_TeamIsSwapped)
				{
					val2 = (Team)1;
				}
				return new TeamRequestReslut(true, val2);
			}
			Team val3 = (Team)1;
			if (settings.m_TeamIsSwapped)
			{
				val3 = (Team)0;
			}
			return new TeamRequestReslut(true, val3);
		}

		internal static bool IsInsideSquare(Vector2 point, Vector2 center, float rotationDegrees, float halfWidth, float halfDepth)
		{
			//IL_0013: 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)
			if (halfWidth <= 0f || halfDepth <= 0f)
			{
				return false;
			}
			ToLocal(point, center, rotationDegrees, out var localX, out var localY);
			if (Mathf.Abs(localX) <= halfWidth)
			{
				return Mathf.Abs(localY) <= halfDepth;
			}
			return false;
		}

		private static Vector3 FacingOutwardInside(Vector2 point, Vector2 center, float rotationDegrees, float halfWidth, float halfDepth)
		{
			//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_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_0090: 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)
			ToLocal(point, center, rotationDegrees, out var localX, out var localY);
			float num = halfWidth - localX;
			float num2 = halfWidth + localX;
			float num3 = halfDepth - localY;
			float num4 = halfDepth + localY;
			float localDirX = 0f;
			float localDirY = 0f;
			if (num <= num2 && num <= num3 && num <= num4)
			{
				localDirX = 1f;
			}
			else if (!(num2 <= num3) || !(num2 <= num4))
			{
				localDirY = ((!(num3 <= num4)) ? (-1f) : 1f);
			}
			else
			{
				localDirX = -1f;
			}
			Vector3 val = LocalDirectionToWorld(localDirX, localDirY, rotationDegrees);
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				return Vector3.forward;
			}
			return ((Vector3)(ref val)).normalized;
		}

		private static Vector3 FacingInwardFromClosestEdge(Vector2 point, Vector2 center, float rotationDegrees, float halfWidth, float halfDepth)
		{
			//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_0027: 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_002d: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			ToLocal(point, center, rotationDegrees, out var localX, out var localY);
			bool flag = Mathf.Abs(localX) > halfWidth;
			bool flag2 = Mathf.Abs(localY) > halfDepth;
			if (!flag && !flag2)
			{
				return FacingOutwardInside(point, center, rotationDegrees, halfWidth, halfDepth);
			}
			float localDirX = 0f;
			float localDirY = 0f;
			if (flag && flag2)
			{
				localDirX = 0f - Mathf.Sign(localX);
				localDirY = 0f - Mathf.Sign(localY);
			}
			else if (flag2)
			{
				localDirY = 0f - Mathf.Sign(localY);
			}
			else
			{
				localDirX = 0f - Mathf.Sign(localX);
			}
			Vector3 val = LocalDirectionToWorld(localDirX, localDirY, rotationDegrees);
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				return Vector3.forward;
			}
			return ((Vector3)(ref val)).normalized;
		}

		private static Vector3 LocalDirectionToWorld(float localDirX, float localDirY, float rotationDegrees)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			float num = rotationDegrees * ((float)Math.PI / 180f);
			float num2 = Mathf.Cos(num);
			float num3 = Mathf.Sin(num);
			float num4 = localDirX * num2 - localDirY * num3;
			float num5 = localDirX * num3 + localDirY * num2;
			return new Vector3(num4, 0f, num5);
		}

		private static void ToLocal(Vector2 point, Vector2 center, float rotationDegrees, out float localX, out float localY)
		{
			//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_001d: 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_0031: 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)
			Vector2 val = point - center;
			float num = rotationDegrees * ((float)Math.PI / 180f);
			float num2 = Mathf.Cos(num);
			float num3 = Mathf.Sin(num);
			localX = val.x * num2 + val.y * num3;
			localY = (0f - val.x) * num3 + val.y * num2;
		}
	}
	internal static class TeamLineSquarePatches
	{
		private static readonly FieldInfo SceneSettingsField = AccessTools.Field(typeof(MapSettingsComponent), "m_sceneSettings");

		private static readonly FieldInfo HasEditedLineField = AccessTools.Field(typeof(MapSettingsComponent), "m_hasEditedLine");

		private static readonly MethodInfo SetEdgeTypeMethod = AccessTools.DeclaredMethod(typeof(MapSettingsComponent), "SetEdgeType", new Type[1] { typeof(int) }, (Type[])null);

		private static readonly FieldInfo MapSettingsIconServiceField = AccessTools.Field(typeof(MapSettingsComponent), "m_iconService");

		private static readonly FieldInfo IsEditingLineField = AccessTools.Field(typeof(SceneSettings), "isEditingLine");

		private static EdgeType _edgeTypeBeforeReset;

		internal static bool GetTeamTerritoryInternal_Prefix(SceneSettings __instance, Vector3 point, out Quaternion rotation, ref TeamRequestReslut __result)
		{
			//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_000c: 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_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)
			rotation = Quaternion.identity;
			if (!ModEdgeTypes.IsSquare(__instance.m_EdgeType))
			{
				return true;
			}
			__result = TeamLineSquareLogic.GetTeamTerritory(__instance, point, out rotation);
			return false;
		}

		internal static bool Update_Prefix(SceneSettings __instance)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (!Application.isPlaying || !ModEdgeTypes.IsSquare(__instance.m_EdgeType))
			{
				TeamLineSquareCameraPatches.UpdateSandboxCameraBlock();
				return true;
			}
			if (!(bool)IsEditingLineField.GetValue(__instance))
			{
				TeamLineSquareCameraPatches.UpdateSandboxCameraBlock();
				return true;
			}
			TeamLineSquareEditing.Apply(__instance);
			return false;
		}

		internal static void ShowCircleSettings_Postfix(SceneSettings __instance, ref bool __result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (ModEdgeTypes.IsSquare(__instance.m_EdgeType))
			{
				__result = true;
			}
		}

		internal static bool CycleLineType_Prefix(MapSettingsComponent __instance)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//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_0030: 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_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_0038: 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_0051: Expected I4, but got Unknown
			//IL_006e: 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)
			SceneSettings val = (SceneSettings)SceneSettingsField.GetValue(__instance);
			if ((Object)(object)val == (Object)null || SetEdgeTypeMethod == null)
			{
				return true;
			}
			EdgeType edgeType = val.m_EdgeType;
			EdgeType val2 = ModEdgeTypes.Next(edgeType);
			if (edgeType == val2)
			{
				return true;
			}
			SetEdgeTypeMethod.Invoke(__instance, new object[1] { (int)val2 });
			HasEditedLineField.SetValue(__instance, true);
			Plugin.LogInfo("Team line type: " + ModEdgeTypes.GetDisplayName(edgeType) + " -> " + ModEdgeTypes.GetDisplayName(val2));
			return false;
		}

		internal static bool MapSettingsGetHelpText_Prefix(MapSettingsComponent __instance, ref string __result)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			SceneSettings val = (SceneSettings)SceneSettingsField.GetValue(__instance);
			if ((Object)(object)val == (Object)null || !ModEdgeTypes.IsSquare(val.m_EdgeType))
			{
				return true;
			}
			__result = TeamLineSquareHelpText.Keyboard;
			TeamLineSquareHelpUi.ApplyToMapSettingsComponent(__instance);
			return false;
		}

		internal static bool MapSettingsUiGetHelpText_Prefix(MapSettingsUI __instance, ref string __result)
		{
			//IL_0010: 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)
			SceneSettings instance = SceneSettings.Instance;
			if ((Object)(object)instance == (Object)null || !ModEdgeTypes.IsSquare(instance.m_EdgeType))
			{
				return true;
			}
			__result = ((PlayerActions.Instance != null && (int)PlayerActions.Instance.InputType == 0) ? TeamLineSquareHelpText.Controller : TeamLineSquareHelpText.Keyboard);
			TeamLineSquareHelpUi.ApplyToMapSettingsUi(__instance);
			return false;
		}

		internal static void StartLineEditing_Postfix(SceneSettings __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (ModEdgeTypes.IsSquare(__instance.m_EdgeType))
			{
				TeamLineSquareDimensions.ResetForEdit(__instance);
			}
		}

		internal static void MapSettingsUiEditTeamLine_Postfix(MapSettingsUI __instance)
		{
			TeamLineSquareHelpUi.ApplyToMapSettingsUi(__instance);
		}

		internal static void MapSettingsComponentStartEditingTeamLine_Postfix(MapSettingsComponent __instance)
		{
			TeamLineSquareHelpUi.ApplyToMapSettingsComponent(__instance);
		}

		internal static void MapSettingsUiStart_Postfix(MapSettingsUI __instance)
		{
			TeamLineSquareDropdown.EnsureSquareOption(__instance);
		}

		internal static void MapSettingsUiUpdateUi_Postfix(MapSettingsUI __instance)
		{
			TeamLineSquareDropdown.SyncValue(__instance);
		}

		internal static bool GlobalTeamEdgeGetSettings_Prefix(EdgeType edgeType, ref TeamEdgeTypeSettings __result)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!ModEdgeTypes.IsSquare(edgeType))
			{
				return true;
			}
			__result = GlobalTeamEdgeSettings.GetSettings((EdgeType)1);
			return false;
		}

		internal static void ResetToDefaultTeamLine_Prefix(SceneSettings __instance)
		{
			//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)
			_edgeTypeBeforeReset = __instance.m_EdgeType;
		}

		internal static void ResetToDefaultTeamLine_Postfix(SceneSettings __instance)
		{
			//IL_0000: 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)
			if (ModEdgeTypes.IsSquare(_edgeTypeBeforeReset))
			{
				__instance.m_EdgeType = ModEdgeTypes.Square;
				TeamLineSquareDimensions.ResetSquareSizeAndDepth(__instance);
				MapSettingsUI val = Object.FindObjectOfType<MapSettingsUI>();
				if ((Object)(object)val != (Object)null)
				{
					TeamLineSquareDropdown.SyncValue(val);
				}
			}
		}
	}
	internal static class TeamLineSquarePlacementPatches
	{
		internal static bool TryRegister(Harmony harmony, ref int applied)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			Type type = ResolveUnitPlacementBrushType();
			MethodInfo methodInfo = ((type != null) ? AccessTools.Method(type, "PlaceLayoutUnitInternal", (Type[])null, (Type[])null) : null);
			if (methodInfo == null)
			{
				Plugin.LogInfo("Square placement patch: UnitPlacementBrush.PlaceLayoutUnitInternal not found; optional layout-facing fix skipped.");
				return false;
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(TeamLineSquarePlacementPatches), "PlaceLayoutUnitInternal_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			applied++;
			return true;
		}

		private static Type ResolveUnitPlacementBrushType()
		{
			return typeof(SceneSettings).Assembly.GetTypes().FirstOrDefault((Type type) => type.Name == "UnitPlacementBrush" && AccessTools.Method(type, "PlaceLayoutUnitInternal", (Type[])null, (Type[])null) != null);
		}

		internal static void PlaceLayoutUnitInternal_Prefix(object unit, ref Quaternion unitRotation)
		{
			//IL_0014: 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_0051: 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)
			if (unit == null)
			{
				return;
			}
			SceneSettings instance = SceneSettings.Instance;
			if (!((Object)(object)instance == (Object)null) && ModEdgeTypes.IsSquare(instance.m_EdgeType))
			{
				object obj = AccessTools.Field(unit.GetType(), "m_position")?.GetValue(unit);
				if (obj is Vector3)
				{
					Vector3 val = (Vector3)obj;
					SceneSettings.GetTeamTerritory(val, ref unitRotation);
				}
			}
		}
	}
	internal static class TeamLineSquareShaderApply
	{
		private static readonly FieldInfo ColorFlipOptionField = AccessTools.Field(typeof(TeamEdgeRenderer), "m_colorFlipOption");

		internal static object TryBuildSquareSheet(object teamEdgeRenderer, object context)
		{
			//IL_0109: 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_012f: 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_014e: 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)
			Shader squareShader = TeamLineSquareAssets.SquareShader;
			if ((Object)(object)squareShader == (Object)null || teamEdgeRenderer == null || context == null)
			{
				return null;
			}
			try
			{
				Type type = context.GetType();
				object obj = type.GetProperty("propertySheets")?.GetValue(context);
				MethodInfo methodInfo = obj?.GetType().GetMethod("Get", new Type[1] { typeof(Shader) });
				if (methodInfo == null)
				{
					return null;
				}
				object obj2 = methodInfo.Invoke(obj, new object[1] { squareShader });
				if (obj2 == null)
				{
					return null;
				}
				object obj3 = obj2.GetType().GetProperty("properties")?.GetValue(obj2);
				if (obj3 == null)
				{
					return null;
				}
				object? obj4 = type.GetProperty("camera")?.GetValue(context);
				Camera val = (Camera)((obj4 is Camera) ? obj4 : null);
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				SceneSettings instance = SceneSettings.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return null;
				}
				TeamEdgeTypeSettings settings = GlobalTeamEdgeSettings.GetSettings(ModEdgeTypes.Square);
				SetVector(obj3, "_DisplayDebugModes", Vector4.zero);
				SetMatrix(obj3, "_InverseView", val.cameraToWorldMatrix);
				SetVector(obj3, "_EdgeInformation", new Vector4(instance.Offset.x, instance.Offset.y, instance.m_Rotation, TeamLineSquareDimensions.HalfDepth(instance)));
				SetFloat(obj3, "_Radius", TeamLineSquareDimensions.HalfWidth(instance));
				SetFloat(obj3, "_EdgeThickness", settings.m_LineThickness * 0.5f);
				SetFloat(obj3, "_EdgePerlinFreq", settings.m_PerlinFrequency);
				SetFloat(obj3, "_EdgePerlinSpeed", settings.m_PerlinScrollSpeed);
				SetFloat(obj3, "_EdgePerlinAmp", settings.m_PerlinStrength);
				SetFloat(obj3, "_DeadzoneThickness", instance.m_DeadzoneSize * 0.5f);
				SetFloat(obj3, "_DeadZoneRotationOffset", settings.m_DeadZoneRotationOffset);
				SetFloat(obj3, "_DeadzoneLineFrequency", settings.m_DeadzoneLineFrequency);
				SetFloat(obj3, "_DeadzoneLineWarpingScale", settings.m_DeadzoneLineWarpingScale);
				SetFloat(obj3, "_DeadzoneLineWarpingFrequency", settings.m_DeadzoneLineWarpingFreqeuncy);
				SetFloat(obj3, "_GradientFalloffDistance", settings.m_GradientFalloffDistance);
				SetFloat(obj3, "_GradientFalloffStrength", settings.m_GradientFalloffStrength);
				SetFloat(obj3, "_FadeFactor", instance.FadeFator);
				ApplyTeamColors(teamEdgeRenderer, instance, settings, obj3);
				return obj2;
			}
			catch (Exception ex)
			{
				Plugin.LogWarning("Square team line sheet build failed: " + ex.Message);
				return null;
			}
		}

		private static void ApplyTeamColors(object teamEdgeRenderer, SceneSettings settings, TeamEdgeTypeSettings edgeSettings, object properties)
		{
			//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_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_009a: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_006c: 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)
			Color blueColor = edgeSettings.m_BlueColor;
			Color redColor = edgeSettings.m_RedColor;
			if (Application.isPlaying)
			{
				object? obj = ColorFlipOptionField?.GetValue(teamEdgeRenderer);
				SettingsInstance val = (SettingsInstance)((obj is SettingsInstance) ? obj : null);
				if (val != null && val.currentValue == 1)
				{
					if (settings.m_TeamIsSwapped)
					{
						SetColor(properties, "_BlueColor", blueColor);
						SetColor(properties, "_RedColor", redColor);
					}
					else
					{
						SetColor(properties, "_BlueColor", redColor);
						SetColor(properties, "_RedColor", blueColor);
					}
					return;
				}
			}
			if (settings.m_TeamIsSwapped)
			{
				SetColor(properties, "_BlueColor", redColor);
				SetColor(properties, "_RedColor", blueColor);
			}
			else
			{
				SetColor(properties, "_BlueColor", blueColor);
				SetColor(properties, "_RedColor", redColor);
			}
		}

		private static void SetFloat(object properties, string name, float value)
		{
			properties.GetType().GetMethod("SetFloat", new Type[2]
			{
				typeof(string),
				typeof(float)
			})?.Invoke(properties, new object[2] { name, value });
		}

		private static void SetColor(object properties, string name, Color value)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			properties.GetType().GetMethod("SetColor", new Type[2]
			{
				typeof(string),
				typeof(Color)
			})?.Invoke(properties, new object[2] { name, value });
		}

		private static void SetVector(object properties, string name, Vector4 value)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			properties.GetType().GetMethod("SetVector", new Type[2]
			{
				typeof(string),
				typeof(Vector4)
			})?.Invoke(properties, new object[2] { name, value });
		}

		private static void SetMatrix(object properties, string name, Matrix4x4 value)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			properties.GetType().GetMethod("SetMatrix", new Type[2]
			{
				typeof(string),
				typeof(Matrix4x4)
			})?.Invoke(properties, new object[2] { name, value });
		}
	}
}
namespace TabsUnlimited.CustomVoices
{
	internal static class CustomVoiceBundleMarker
	{
		internal const int ModId = -998;

		internal const string VocalRefPrefix = "TabsUnlimited.CustomVoice/";

		internal static string BuildVocalRef(string packId)
		{
			return "TabsUnlimited.CustomVoice/" + packId;
		}

		internal static bool IsCustomVocalRef(string vocalRef)
		{
			if (!string.IsNullOrEmpty(vocalRef))
			{
				return vocalRef.StartsWith("TabsUnlimited.CustomVoice/", StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		internal static bool TryParsePackId(string vocalRef, out string packId)
		{
			packId = null;
			if (!IsCustomVocalRef(vocalRef))
			{
				return false;
			}
			packId = vocalRef.Substring("TabsUnlimited.CustomVoice/".Length);
			return !string.IsNullOrEmpty(packId);
		}

		internal static bool IsCustomBundle(VoiceBundle bundle)
		{
			if ((Object)(object)bundle != (Object)null)
			{
				return IsCustomVocalRef(bundle.VocalRef);
			}
			return false;
		}

		internal static DatabaseID ToDatabaseId(string packId)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			int num = StableHash(packId);
			return new DatabaseID(-998, num);
		}

		internal static bool TryGetPackId(DatabaseID id, out string packId)
		{
			//IL_0003: 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)
			packId = null;
			if (id.m_modID != -998)
			{
				return false;
			}
			return CustomVoiceRegistry.TryGetPackIdByDatabaseId(id, out packId);
		}

		private static int StableHash(string value)
		{
			int num = -2128831035;
			for (int i = 0; i < value.Length; i++)
			{
				num ^= value[i];
				num *= 16777619;
			}
			if (num != 0)
			{
				return num;
			}
			return 1;
		}
	}
	internal static class CustomVoiceEditorHelper
	{
		private static readonly FieldInfo UnitBasesField = AccessTools.Field(typeof(UnitEditorManager), "UnitBases");

		internal static bool TryGetClubberVoiceBundle(UnitEditorManager manager, out VoiceBundle bundle)
		{
			bundle = null;
			if ((Object)(object)manager == (Object)null || UnitBasesField == null)
			{
				return false;
			}
			if (!(UnitBasesField.GetValue(manager) is UnitBaseWrapper[] array) || array.Length == 0)
			{
				return false;
			}
			foreach (UnitBaseWrapper val in array)
			{
				if (!((Object)(object)val?.UnitBaseBlueprint?.voiceBundle == (Object)null) && val.BaseDisplayName != null && val.BaseDisplayName.IndexOf("Clubber", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					bundle = val.UnitBaseBlueprint.voiceBundle;
					return true;
				}
			}
			if ((Object)(object)array[0]?.UnitBaseBlueprint?.voiceBundle != (Object)null)
			{
				bundle = array[0].UnitBaseBlueprint.voiceBundle;
				return true;
			}
			return false;
		}

		internal static void RevertEquippedVoiceIfDeleted(string deletedPackId)
		{
			if (string.IsNullOrEmpty(deletedPackId))
			{
				return;
			}
			UnitEditorManager val = Object.FindObjectOfType<UnitEditorManager>();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			VoiceBundle voiceBundle = val.GetVoiceBundle();
			if (!((Object)(object)voiceBundle == (Object)null) && CustomVoiceBundleMarker.TryParsePackId(voiceBundle.VocalRef, out var packId) && string.Equals(packId, deletedPackId, StringComparison.OrdinalIgnoreCase))
			{
				if (!TryGetClubberVoiceBundle(val, out var bundle) || (Object)(object)bundle == (Object)null)
				{
					Plugin.LogWarning("Custom voice: could not resolve Clubber voice after deleting pack " + deletedPackId);
					return;
				}
				val.EquipedVoiceBundle(bundle);
				Plugin.LogInfo("Custom voice: reverted equipped voice to Clubber after deleting pack " + deletedPackId);
			}
		}
	}
	internal static class CustomVoiceIconHelper
	{
		internal static string Serialize(DatabaseID id)
		{
			return id.m_modID + ":" + id.m_ID;
		}

		internal static bool TryParse(string value, out DatabaseID id)
		{
			//IL_0001: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			id = default(DatabaseID);
			if (string.IsNullOrEmpty(value))
			{
				return false;
			}
			string[] array = value.Split(new char[1] { ':' });
			if (array.Length != 2)
			{
				return false;
			}
			if (!int.TryParse(array[0], out var result))
			{
				return false;
			}
			if (!int.TryParse(array[1], out var result2))
			{
				return false;
			}
			id = new DatabaseID(result, result2);
			return true;
		}

		internal static string GetDefaultIconId()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			ContentDatabase val = ContentDatabase.Instance();
			if (val == null)
			{
				return null;
			}
			foreach (FactionIcon factionIcon in val.GetFactionIcons())
			{
				if (((factionIcon != null) ? factionIcon.Entity : null) != null)
				{
					return Serialize(factionIcon.Entity.GUID);
				}
			}
			return null;
		}

		internal static FactionIcon GetFactionIcon(string iconId)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!TryParse(iconId, out var id))
			{
				return null;
			}
			ContentDatabase obj = ContentDatabase.Instance();
			if (obj == null)
			{
				return null;
			}
			return obj.GetFactionIcon(id);
		}

		internal static FactionIcon[] GetAllFactionIcons()
		{
			ContentDatabase val = ContentDatabase.Instance();
			if (val == null)
			{
				return (FactionIcon[])(object)new FactionIcon[0];
			}
			List<FactionIcon> list = new List<FactionIcon>();
			foreach (FactionIcon factionIcon in val.GetFactionIcons())
			{
				if ((Object)(object)factionIcon != (Object)null)
				{
					list.Add(factionIcon);
				}
			}
			return list.ToArray();
		}

		internal static void ApplySpriteToImage(string iconId, Image image, Action onComplete = null)
		{
			if ((Object)(object)image == (Object)null)
			{
				onComplete?.Invoke();
				return;
			}
			FactionIcon factionIcon = GetFactionIcon(iconId);
			if (((factionIcon != null) ? factionIcon.Entity : null) == null)
			{
				onComplete?.Invoke();
				return;
			}
			if ((Object)(object)factionIcon.Entity.SpriteIcon != (Object)null)
			{
				image.sprite = factionIcon.Entity.SpriteIcon;
				onComplete?.Invoke();
				return;
			}
			factionIcon.Entity.GetSpriteIconAsync((Action<Sprite>)delegate(Sprite sprite)
			{
				if ((Object)(object)sprite != (Object)null && (Object)(object)image != (Object)null)
				{
					image.sprite = sprite;
				}
				onComplete?.Invoke();
			});
		}

		internal static void ApplySpriteToEntity(string iconId, DatabaseEntity entity)
		{
			if (entity == null)
			{
				return;
			}
			FactionIcon factionIcon = GetFactionIcon(iconId);
			if (((factionIcon != null) ? factionIcon.Entity : null) == null)
			{
				return;
			}
			if ((Object)(object)factionIcon.Entity.SpriteIcon != (Object)null)
			{
				entity.SpriteIcon = factionIcon.Entity.SpriteIcon;
				return;
			}
			factionIcon.Entity.GetSpriteIconAsync((Action<Sprite>)delegate(Sprite sprite)
			{
				if ((Object)(object)sprite != (Object)null && entity != null)
				{
					entity.SpriteIcon = sprite;
				}
			});
		}
	}
	internal sealed class CustomVoiceOggEntry
	{
		internal string FileName;

		internal string FullPath;

		internal string DisplayName;

		internal float DurationSeconds;
	}
	internal static class CustomVoiceOggCatalog
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass22_0
		{
			public float? duration;

			internal void <RefreshRoutine>b__1(float? value)
			{
				duration = value;
			}
		}

		[CompilerGenerated]
		private sealed class <RefreshRoutine>d__22 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass22_0 <>8__1;

			public Action onComplete;

			private string[] <paths>5__2;

			private int <i>5__3;

			private string <path>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RefreshRoutine>d__22(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<paths>5__2 = null;
				<path>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					if (!<>8__1.duration.HasValue)
					{
						RejectedUnreadableCount++;
					}
					else if (!CustomVoiceOggDuration.IsEligibleDuration(<>8__1.duration.Value))
					{
						RejectedTooLongCount++;
					}
					else
					{
						string fileName = Path.GetFileName(<path>5__4);
						Entries.Add(new CustomVoiceOggEntry
						{
							FileName = fileName,
							FullPath = <path>5__4,
							DisplayName = Path.GetFileNameWithoutExtension(fileName),
							DurationSeconds = <>8__1.duration.Value
						});
						<>8__1 = null;
						<path>5__4 = null;
					}
					<i>5__3++;
				}
				else
				{
					<>1__state = -1;
					ScanInProgress = true;
					RejectedTooLongCount = 0;
					RejectedUnreadableCount = 0;
					Entries.Clear();
					CustomVoicePaths.EnsureDirectories();
					if (!Directory.Exists(CustomVoicePaths.SourcesDirectory))
					{
						goto IL_01cb;
					}
					<paths>5__2 = Directory.GetFiles(CustomVoicePaths.SourcesDirectory, "*.ogg", SearchOption.TopDirectoryOnly).OrderBy<string, string>((string p) => p, StringComparer.OrdinalIgnoreCase).ToArray();
					<i>5__3 = 0;
				}
				if (<i>5__3 < <paths>5__2.Length)
				{
					<>8__1 = new <>c__DisplayClass22_0();
					<path>5__4 = <paths>5__2[<i>5__3];
					<>8__1.duration = null;
					<>2__current = CustomVoiceOggDuration.ProbeDurationRoutine(<path>5__4, delegate(float? value)
					{
						<>8__1.duration = value;
					});
					<>1__state = 1;
					return true;
				}
				<paths>5__2 = null;
				goto IL_01cb;
				IL_01cb:
				_lastScanUtc = DateTime.UtcNow;
				ScanInProgress = false;
				CustomVoiceStore.PurgeIneligibleFromSavedPacks(IsFileEligible);
				onComplete?.Invoke();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly List<CustomVoiceOggEntry> Entries = new List<CustomVoiceOggEntry>();

		private static DateTime _lastScanUtc;

		internal static IReadOnlyList<CustomVoiceOggEntry> EntriesSnapshot => Entries;

		internal static int RejectedTooLongCount { get; private set; }

		internal static int RejectedUnreadableCount { get; private set; }

		internal static bool ScanInProgress { get; private set; }

		internal static void BeginRefresh(Action onComplete = null)
		{
			if ((Object)(object)Plugin.Instance == (Object)null)
			{
				RefreshSyncWithoutDurationCheck();
				onComplete?.Invoke();
			}
			else
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(RefreshRoutine(onComplete));
			}
		}

		internal static void Refresh()
		{
			BeginRefresh();
		}

		internal static bool IsFileEligible(string fileName)
		{
			return FindByFileName(fileName) != null;
		}

		internal static bool TryDeleteSourceFile(string fileName)
		{
			if (string.IsNullOrEmpty(fileName))
			{
				return false;
			}
			string text = CustomVoicePaths.ResolveSourceFile(fileName);
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			try
			{
				if (File.Exists(text))
				{
					File.Delete(text);
				}
			}
			catch (Exception ex)
			{
				Plugin.LogWarning("Custom voice: failed to delete " + fileName + ": " + ex.Message);
				return false;
			}
			int num = CustomVoiceStore.RemoveFileFromAllPacks(fileName);
			if (num > 0)
			{
				Plugin.LogInfo($"Custom voice: removed {fileName} from {num} pack(s).");
			}
			BeginRefresh();
			return true;
		}

		internal static string GetSummaryText()
		{
			if (ScanInProgress)
			{
				return "Scanning .ogg files…";
			}
			if (Entries.Count == 0 && RejectedTooLongCount == 0 && RejectedUnreadableCount == 0)
			{
				return "No eligible .ogg files yet. Use Open File to open CustomContent/voices and copy .ogg files there (max " + 7f.ToString("0.#") + "s each).";
			}
			string text = $"{Entries.Count} eligible source file(s) — last scan {_lastScanUtc.ToLocalTime():HH:mm:ss}";
			if (RejectedTooLongCount > 0)
			{
				text += $" · {RejectedTooLongCount} skipped (>{7f:0.#}s)";
			}
			if (RejectedUnreadableCount > 0)
			{
				text += $" · {RejectedUnreadableCount} unreadable";
			}
			return text;
		}

		internal static CustomVoiceOggEntry FindByFileName(string fileName)
		{
			if (string.IsNullOrEmpty(fileName))
			{
				return null;
			}
			for (int i = 0; i < Entries.Count; i++)
			{
				if (string.Equals(Entries[i].FileName, fileName, StringComparison.OrdinalIgnoreCase))
				{
					return Entries[i];
				}
			}
			return null;
		}

		[IteratorStateMachine(typeof(<RefreshRoutine>d__22))]
		private static IEnumerator RefreshRoutine(Action onComplete)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RefreshRoutine>d__22(0)
			{
				onComplete = onComplete
			};
		}

		private static void RefreshSyncWithoutDurationCheck()
		{
			Entries.Clear();
			RejectedTooLongCount = 0;
			RejectedUnreadableCount = 0;
			CustomVoicePaths.EnsureDirectories();
			if (!Directory.Exists(CustomVoicePaths.SourcesDirectory))
			{
				_lastScanUtc = DateTime.UtcNow;
				return;
			}
			foreach (string item in Directory.GetFiles(CustomVoicePaths.SourcesDirectory, "*.ogg", SearchOption.TopDirectoryOnly).OrderBy<string, string>((string p) => p, StringComparer.OrdinalIgnoreCase))
			{
				string fileName = Path.GetFileName(item);
				Entries.Add(new CustomVoiceOggEntry
				{
					FileName = fileName,
					FullPath = item,
					DisplayName = Path.GetFileNameWithoutExtension(fileName)
				});
			}
			_lastScanUtc = DateTime.UtcNow;
		}
	}
	internal static class CustomVoiceOggDuration
	{
		private struct CacheEntry
		{
			internal long WriteTimeUtcTicks;

			internal float DurationSeconds;
		}

		[CompilerGenerated]
		private sealed class <ProbeDurationRoutine>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string fullPath;

			public Action<float?> done;

			private string <fileName>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ProbeDurationRoutine>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<fileName>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					if (TryGetCachedDuration(fullPath, out var durationSeconds))
					{
						done?.Invoke(durationSeconds);
						return false;
					}
					<fileName>5__2 = Path.GetFileName(fullPath);
					<>2__current = CustomVoicePreview.EnsureClipLoaded(<fileName>5__2);
					<>1__state = 1;
					return true;
				}
				case 1:
				{
					<>1__state = -1;
					AudioClip cachedClip = CustomVoicePreview.GetCachedClip(<fileName>5__2);
					if ((Object)(object)cachedClip == (Object)null)
					{
						done?.Invoke(null);
						return false;
					}
					CacheDuration(fullPath, cachedClip.length);
					done?.Invoke(cachedClip.length);
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly Dictionary<string, CacheEntry> Cache = new Dictionary<string, CacheEntry>(StringComparer.OrdinalIgnoreCase);

		internal static bool IsEligibleDuration(float durationSeconds)
		{
			if (durationSeconds > 0f)
			{
				return durationSeconds <= 7f;
			}
			return false;
		}

		internal static bool TryGetCachedDuration(string fullPath, out float durationSeconds)
		{
			durationSeconds = 0f;
			if (string.IsNullOrEmpty(fullPath) || !File.Exists(fullPath))
			{
				return false;
			}
			long ticks = File.GetLastWriteTimeUtc(fullPath).Ticks;
			if (!Cache.TryGetValue(fullPath, out var value) || value.WriteTimeUtcTicks != ticks)
			{
				return false;
			}
			durationSeconds = value.DurationSeconds;
			return durationSeconds > 0f;
		}

		internal static void CacheDuration(string fullPath, float durationSeconds)
		{
			if (!string.IsNullOrEmpty(fullPath) && File.Exists(fullPath))
			{
				Cache[fullPath] = new CacheEntry
				{
					WriteTimeUtcTicks = File.GetLastWriteTimeUtc(fullPath).Ticks,
					DurationSeconds = durationSeconds
				};
			}
		}

		[IteratorStateMachine(typeof(<ProbeDurationRoutine>d__5))]
		internal static IEnumerator ProbeDurationRoutine(string fullPath, Action<float?> done)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ProbeDurationRoutine>d__5(0)
			{
				fullPath = fullPath,
				done = done
			};
		}
	}
	internal static class CustomVoiceOggImporter
	{
		internal static void OpenSourcesFolder()
		{
			CustomVoicePaths.EnsureDirectories();
			try
			{
				Process.Start(new ProcessStartInfo
				{
					FileName = CustomVoicePaths.SourcesDirectory,
					UseShellExecute = true
				});
			}
			catch (Exception ex)
			{
				Plugin.LogWarning("Custom voice: failed to open voices folder: " + ex.Message);
			}
		}
	}
	internal class CustomVoiceOneShotPlayer : MonoBehaviour
	{
		private const float PitchLerpSpeed = 5f;

		private AudioSource _source;

		private float _defaultPitch;

		private bool _stopping;

		internal void Play(AudioSource source, float defaultPitch)
		{
			_source = source;
			_defaultPitch = Mathf.Max(defaultPitch, 0.01f);
			_source.pitch = _defaultPitch * Time.timeScale;
			_source.Play();
			CustomVoiceRuntime.RegisterActive(this);
		}

		internal void StopAndDestroy()
		{
			if (!_stopping)
			{
				_stopping = true;
				if ((Object)(object)_source != (Object)null)
				{
					_source.Stop();
				}
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void OnDestroy()
		{
			CustomVoiceRuntime.UnregisterActive(this);
		}

		private void Update()
		{
			if ((Object)(object)_source == (Object)null || !_source.isPlaying)
			{
				StopAndDestroy();
				return;
			}
			if (_source.spatialBlend > 0.1f)
			{
				float num = _defaultPitch * Time.timeScale;
				_source.pitch = Mathf.Lerp(_source.pitch, num, Time.unscaledDeltaTime * 5f);
			}
			if (_source.time >= 7f)
			{
				StopAndDestroy();
			}
		}
	}
	[Serializable]
	internal sealed class CustomVoicePack
	{
		internal const int MaxVocalLines = 5;

		internal const int MaxDeathLines = 2;

		public string id;

		public string name;

		public string iconId;

		public List<string> vocalFiles = new List<string>();

		public List<string> deathFiles = new List<string>();

		public string createdUtc;

		internal static CustomVoicePack CreateNew(string displayName)
		{
			return new CustomVoicePack
			{
				id = Guid.NewGuid().ToString("N"),
				name = (string.IsNullOrWhiteSpace(displayName) ? "Custom Voice" : displayName.Trim()),
				iconId = CustomVoiceIconHelper.GetDefaultIconId(),
				createdUtc = DateTime.UtcNow.ToString("o")
			};
		}

		internal void Sanitize()
		{
			vocalFiles = TrimList(vocalFiles, 5);
			deathFiles = TrimList(deathFiles, 2);
			if (string.IsNullOrWhiteSpace(name))
			{
				name = "Custom Voice";
			}
			if (string.IsNullOrEmpty(iconId))
			{
				iconId = CustomVoiceIconHelper.GetDefaultIconId();
			}
		}

		internal CustomVoicePack Clone()
		{
			return new CustomVoicePack
			{
				id = id,
				name = name,
				iconId = iconId,
				createdUtc = createdUtc,
				vocalFiles = new List<string>(vocalFiles ?? new List<string>()),
				deathFiles = new List<string>(deathFiles ?? new List<string>())
			};
		}

		private static List<string> TrimList(List<string> source, int max)
		{
			List<string> list = new List<string>();
			if (source == null)
			{
				return list;
			}
			foreach (string item in source)
			{
				if (!string.IsNullOrWhiteSpace(item))
				{
					list.Add(Path.GetFileName(item.Trim()));
					if (list.Count >= max)
					{
						break;
					}
				}
			}
			return list;
		}
	}
	internal static class CustomVoicePaths
	{
		internal const string LegacySourcesFolderName = "CustomVoices/Sources";

		internal const string PacksFolderName = "CustomVoices/Packs";

		internal static string PluginDirectory => Path.GetDirectoryName(typeof(Plugin).Assembly.Location) ?? Paths.PluginPath;

		internal static string SourcesDirectory => Path.Combine(Application.dataPath, "CustomContent", "voices");

		internal static string LegacySourcesDirectory => Path.Combine(PluginDirectory, "CustomVoices/Sources".Replace('/', Path.DirectorySeparatorChar));

		internal static string PacksDirectory => Path.Combine(PluginDirectory, "CustomVoices/Packs".Replace('/', Path.DirectorySeparatorChar));

		internal static void EnsureDirectories()
		{
			Directory.CreateDirectory(SourcesDirectory);
			Directory.CreateDirectory(PacksDirectory);
		}

		internal static void MigrateLegacySourcesIfNeeded()
		{
			EnsureDirectories();
			if (!Directory.Exists(LegacySourcesDirectory))
			{
				return;
			}
			string[] files = Directory.GetFiles(LegacySourcesDirectory, "*.ogg", SearchOption.TopDirectoryOnly);
			if (files.Length == 0 || (Directory.Exists(SourcesDirectory) && Directory.GetFiles(SourcesDirectory, "*.ogg", SearchOption.TopDirectoryOnly).Length != 0))
			{
				return;
			}
			int num = 0;
			string[] array = files;
			foreach (string text in array)
			{
				string fileName = Path.GetFileName(text);
				if (!string.IsNullOrEmpty(fileName))
				{
					string text2 = Path.Combine(SourcesDirectory, fileName);
					if (!File.Exists(text2))
					{
						File.Copy(text, text2);
						num++;
					}
				}
			}
			if (num > 0)
			{
				Plugin.LogInfo($"Custom voice: migrated {num} .ogg file(s) from plugin Sources to CustomContent/voices.");
			}
		}

		internal static string ResolveSourceFile(string fileName)
		{
			if (string.IsNullOrEmpty(fileName))
			{
				return null;
			}
			return Path.Combine(SourcesDirectory, fileName);
		}
	}
	internal static class CustomVoicePreview
	{
		[CompilerGenerated]
		private sealed class <EnsureClipLoaded>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string fileName;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EnsureClipLoaded>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					if (string.IsNullOrEmpty(fileName))
					{
						return false;
					}
					if (ClipCache.ContainsKey(fileName))
					{
						return false;
					}
					string text = CustomVoicePaths.ResolveSourceFile(fileName);
					if (!File.Exists(text))
					{
						return false;
					}
					<>2__current = LoadClipRoutine(text, fileName);
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <LoadClipRoutine>d__8 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string fullPath;

			public string cacheKey;

			private UnityWebRequest <request>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LoadClipRoutine>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<request>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				bool result;
				try
				{
					switch (<>1__state)
					{
					default:
						result = false;
						break;
					case 0:
					{
						<>1__state = -1;
						string absoluteUri = new Uri(fullPath).AbsoluteUri;
						<request>5__2 = UnityWebRequestMultimedia.GetAudioClip(absoluteUri, (AudioType)14);
						<>1__state = -3;
						<>2__current = <request>5__2.SendWebRequest();
						<>1__state = 1;
						result = true;
						break;
					}
					case 1:
					{
						<>1__state = -3;
						if (<request>5__2.isNetworkError || <request>5__2.isHttpError)
						{
							Plugin.LogWarning("Custom voice: failed to load " + cacheKey + ": " + <request>5__2.error);
							result = false;
							<>m__Finally1();
							break;
						}
						AudioClip content = DownloadHandlerAudioClip.GetContent(<request>5__2);
						if ((Object)(object)content != (Object)null)
						{
							ClipCache[cacheKey] = content;
						}
						<>m__Finally1();
						<request>5__2 = null;
						result = false;
						break;
					}
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<request>5__2 != null)
				{
					((IDisposable)<request>5__2).Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <PlayRoutine>d__7 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string fullPath;

			public float pitch;

			private string <fileName>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <PlayRoutine>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<fileName>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				AudioClip value;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<fileName>5__2 = Path.GetFileName(fullPath);
					if (!ClipCache.TryGetValue(<fileName>5__2, out value) || (Object)(object)value == (Object)null)
					{
						<>2__current = LoadClipRoutine(fullPath, <fileName>5__2);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					ClipCache.TryGetValue(<fileName>5__2, out value);
					break;
				}
				if ((Object)(object)value == (Object)null)
				{
					return false;
				}
				EnsurePreviewSource();
				_previewSource.volume = 0.18f;
				_previewSource.clip = value;
				_previewSource.pitch = ((pitch <= 0f) ? 1f : pitch);
				_previewSource.Play();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly Dictionary<string, AudioClip> ClipCache = new Dictionary<string, AudioClip>(StringComparer.OrdinalIgnoreCase);

		private static AudioSource _previewSource;

		internal static void PlayFile(string fileName, float pitch = 1f)
		{
			if (!string.IsNullOrEmpty(fileName))
			{
				string text = CustomVoicePaths.ResolveSourceFile(fileName);
				if (!File.Exists(text))
				{
					Plugin.LogWarning("Custom voice preview: missing file " + fileName);
				}
				else if (!((Object)(object)Plugin.Instance == (Object)null))
				{
					((MonoBehaviour)Plugin.Instance).StartCoroutine(PlayRoutine(text, pitch));
				}
			}
		}

		internal static void PlayRandomVocal(CustomVoicePack pack, float pitch = 1f)
		{
			string text = PickRandom(pack?.vocalFiles);
			if (text != null)
			{
				PlayFile(text, pitch);
			}
		}

		internal static AudioClip GetCachedClip(string fileName)
		{
			if (string.IsNullOrEmpty(fileName))
			{
				return null;
			}
			ClipCache.TryGetValue(fileName, out var value);
			return value;
		}

		[IteratorStateMachine(typeof(<EnsureClipLoaded>d__5))]
		internal static IEnumerator EnsureClipLoaded(string fileName)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnsureClipLoaded>d__5(0)
			{
				fileName = fileName
			};
		}

		private static string PickRandom(List<string> files)
		{
			if (files == null || files.Count == 0)
			{
				return null;
			}
			return files[Random.Range(0, files.Count)];
		}

		[IteratorStateMachine(typeof(<PlayRoutine>d__7))]
		private static IEnumerator PlayRoutine(string fullPath, float pitch)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayRoutine>d__7(0)
			{
				fullPath = fullPath,
				pitch = pitch
			};
		}

		[IteratorStateMachine(typeof(<LoadClipRoutine>d__8))]
		private static IEnumerator LoadClipRoutine(string fullPath, string cacheKey)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadClipRoutine>d__8(0)
			{
				fullPath = fullPath,
				cacheKey = cacheKey
			};
		}

		private static void EnsurePreviewSource()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_previewSource != (Object)null))
			{
				GameObject val = new GameObject("TabsUnlimited_CustomVoicePreview");
				Object.DontDestroyOnLoad((Object)val);
				_previewSource = val.AddComponent<AudioSource>();
				_previewSource.playOnAwake = false;
				_previewSource.spatialBlend = 0f;
				_previewSource.volume = 0.18f;
				val.AddComponent<CustomVoicePreviewController>();
			}
		}
	}
	internal class CustomVoicePreviewController : MonoBehaviour
	{
		private AudioSource _source;

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

		private void Update()
		{
			if (!((Object)(object)_source == (Object)null) && _source.isPlaying && _source.time >= 7f)
			{
				_source.Stop();
			}
		}
	}
	internal static class CustomVoiceRegistry
	{
		private static readonly Dictionary<string, VoiceBundle> BundlesByPackId = new Dictionary<string, VoiceBundle>();

		private static readonly Dictionary<int, string> PackIdByDatabaseId = new Dictionary<int, string>();

		private static readonly List<VoiceBundle> BundleList = new List<VoiceBundle>();

		internal static IReadOnlyList<VoiceBundle> AllCustomBundles => BundleList;

		internal static void Initialize()
		{
			CustomVoicePaths.MigrateLegacySourcesIfNeeded();
			CustomVoiceStore.LoadAll();
			RefreshFromStore();
		}

		internal static void RefreshFromStore()
		{
			//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_0076: Unknown result type (might be due to invalid IL or missing references)
			BundlesByPackId.Clear();
			PackIdByDatabaseId.Clear();
			BundleList.Clear();
			foreach (CustomVoicePack allPack in CustomVoiceStore.AllPacks)
			{
				if (allPack != null && !string.IsNullOrEmpty(allPack.id))
				{
					VoiceBundle val = CreateBundle(allPack);
					BundlesByPackId[allPack.id] = val;
					BundleList.Add(val);
					DatabaseID val2 = CustomVoiceBundleMarker.ToDatabaseId(allPack.id);
					PackIdByDatabaseId[val2.m_ID] = allPack.id;
				}
			}
		}

		internal static bool TryGetPackIdByDatabaseId(DatabaseID id, out string packId)
		{
			//IL_0003: 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)
			packId = null;
			if (id.m_modID != -998)
			{
				return false;
			}
			return PackIdByDatabaseId.TryGetValue(id.m_ID, out packId);
		}

		internal static bool TryGetPackByBundle(VoiceBundle bundle, out CustomVoicePack pack)
		{
			pack = null;
			if ((Object)(object)bundle == (Object)null || !CustomVoiceBundleMarker.TryParsePackId(bundle.VocalRef, out var packId))
			{
				return false;
			}
			pack = CustomVoiceStore.GetById(packId);
			return pack != null;
		}

		internal static bool TryGetBundle(string packId, out VoiceBundle bundle)
		{
			return BundlesByPackId.TryGetValue(packId, out bundle);
		}

		internal static bool IsCustomBundle(VoiceBundle bundle)
		{
			return CustomVoiceBundleMarker.IsCustomBundle(bundle);
		}

		private static VoiceBundle CreateBundle(CustomVoicePack pack)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			VoiceBundle obj = ScriptableObject.CreateInstance<VoiceBundle>();
			((Object)obj).name = "CustomVoice_" + pack.id;
			obj.VocalRef = CustomVoiceBundleMarker.BuildVocalRef(pack.id);
			obj.DeathRef = CustomVoiceBundleMarker.BuildVocalRef(pack.id);
			DatabaseEntity val = new DatabaseEntity((WorkshopContentType)0);
			val.Name = pack.name;
			val.GUID = CustomVoiceBundleMarker.ToDatabaseId(pack.id);
			CustomVoiceIconHelper.ApplySpriteToEntity(pack.iconId, val);
			obj.Entity = val;
			return obj;
		}
	}
	internal static class CustomVoiceRuntime
	{
		[CompilerGenerated]
		private sealed class <PlayLineRoutine>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string fileName;

			public Vector3 pos;

			public float pitch;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <PlayLineRoutine>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//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_007d: 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)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = CustomVoicePreview.EnsureClipLoaded(fileName);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					AudioClip cachedClip = CustomVoicePreview.GetCachedClip(fileName);
					if ((Object)(object)cachedClip == (Object)null)
					{
						return false;
					}
					GameObject val = new GameObject("TabsUnlimited_CustomVoiceOneShot");
					AudioSource val2 = val.AddComponent<AudioSource>();
					val2.clip = cachedClip;
					val2.volume = 0.5f;
					val2.spatialBlend = 1f;
					val.transform.position = pos;
					val.AddComponent<CustomVoiceOneShotPlayer>().Play(val2, pitch);
					return false;
				}
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly Dictionary<int, string> PackIdByUnitInstance = new Dictionary<int, string>();

		private static readonly List<CustomVoiceOneShotPlayer> ActiveOneShots = new List<CustomVoiceOneShotPlayer>();

		internal static void RegisterActive(CustomVoiceOneShotPlayer player)
		{
			if ((Object)(object)player != (Object)null && !ActiveOneShots.Contains(player))
			{
				ActiveOneShots.Add(player);
			}
		}

		internal static void UnregisterActive(CustomVoiceOneShotPlayer player)
		{
			if ((Object)(object)player != (Object)null)
			{
				ActiveOneShots.Remove(player);
			}
		}

		internal static void StopAllActive()
		{
			if (ActiveOneShots.Count == 0)
			{
				return;
			}
			CustomVoiceOneShotPlayer[] array = ActiveOneShots.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				if ((Object)(object)array[i] != (Object)null)
				{
					array[i].StopAndDestroy();
				}
			}
			ActiveOneShots.Clear();
		}

		internal static void RegisterUnit(Unit unit, VoiceBundle voiceBundle)
		{
			if (!((Object)(object)unit == (Object)null) && !((Object)(object)voiceBundle == (Object)null) && CustomVoiceRegistry.IsCustomBundle(voiceBundle) && CustomVoiceRegistry.TryGetPackByBundle(voiceBundle, out var _) && CustomVoiceBundleMarker.TryParsePackId(voiceBundle.VocalRef, out var packId))
			{
				PackIdByUnitInstance[((Object)unit).GetInstanceID()] = packId;
			}
		}

		internal static bool TryPlayCustomVocal(UnitSounds sounds, int vocalType, float str, Vector3 pos)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)sounds == (Object)null || !TryGetPackForSounds(sounds, out var pack))
			{
				return false;
			}
			if (pack.vocalFiles == null || pack.vocalFiles.Count == 0)
			{
				return false;
			}
			if (Random.value > str)
			{
				return true;
			}
			string text = PickEligibleRandomFile(pack.vocalFiles);
			if (text == null)
			{
				return false;
			}
			PlayLine(sounds, text, pos);
			return true;
		}

		internal static bool TryPlayCustomDeath(UnitSounds sounds, float str, Vector3 pos)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)sounds == (Object)null || !TryGetPackForSounds(sounds, out var pack))
			{
				return false;
			}
			if (pack.deathFiles == null || pack.deathFiles.Count == 0)
			{
				return false;
			}
			if (Random.value > str)
			{
				return true;
			}
			string text = PickEligibleRandomFile(pack.deathFiles);
			if (text == null)
			{
				return false;
			}
			PlayLine(sounds, text, pos);
			return true;
		}

		internal static bool TryPlayBlueprintVocal(UnitBlueprint blueprint, Vector3 pos, float pitchMultiplier = 1f)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)blueprint?.voiceBundle == (Object)null || !CustomVoiceRegistry.TryGetPackByBundle(blueprint.voiceBundle, out var pack))
			{
				return false;
			}
			if (pack.vocalFiles == null || pack.vocalFiles.Count == 0)
			{
				return false;
			}
			string text = PickEligibleRandomFile(pack.vocalFiles);
			if (text == null)
			{
				return false;
			}
			float num = ((blueprint.VoicePitch > 0f) ? blueprint.VoicePitch : 1f);
			PlayLineAt(text, pos, num * pitchMultiplier);
			return true;
		}

		private static void PlayLine(UnitSounds sounds, string fileName, Vector3 pos)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			float pitch = (((Object)(object)sounds != (Object)null && sounds.Pitch > 0f) ? sounds.Pitch : 1f);
			PlayLineAt(fileName, pos, pitch);
		}

		private static void PlayLineAt(string fileName, Vector3 pos, float pitch)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Plugin.Instance == (Object)null))
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(PlayLineRoutine(fileName, pos, pitch));
			}
		}

		[IteratorStateMachine(typeof(<PlayLineRoutine>d__11))]
		private static IEnumerator PlayLineRoutine(string fileName, Vector3 pos, float pitch)
		{
			//IL_000e: 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)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayLineRoutine>d__11(0)
			{
				fileName = fileName,
				pos = pos,
				pitch = pitch
			};
		}

		private static bool TryGetPackForSounds(UnitSounds sounds, out CustomVoicePack pack)
		{
			pack = null;
			if ((Object)(object)sounds == (Object)null)
			{
				return false;
			}
			Unit val = ((Component)sounds).GetComponentInParent<Unit>() ?? ((Component)sounds).GetComponent<Unit>();
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (!PackIdByUnitInstance.TryGetValue(((Object)val).GetInstanceID(), out var value))
			{
				UnitBlueprint unitBlueprint = val.unitBlueprint;
				if ((Object)(object)unitBlueprint?.voiceBundle == (Object)null || !CustomVoiceRegistry.TryGetPackByBundle(unitBlueprint.voiceBundle, out pack))
				{
					return false;
				}
				value = pack.id;
				PackIdByUnitInstance[((Object)val).GetInstanceID()] = value;
				return true;
			}
			pack = CustomVoiceStore.GetById(value);
			return pack != null;
		}

		private static string PickEligibleRandomFile(List<string> files)
		{
			if (files == null || files.Count == 0)
			{
				return null;
			}
			string result = null;
			int num = 0;
			for (int i = 0; i < files.Count; i++)
			{
				string text = files[i];
				if (CustomVoiceOggCatalog.IsFileEligible(text))
				{
					num++;
					if (Random.Range(0, num) == 0)
					{
						result = text;
					}
				}
			}
			return result;
		}
	}
	internal static class CustomVoiceDatabasePatches
	{
		internal static void Register(Harmony harmony, ref int applied)
		{
			if (UnitEditorConfig.CustomVoicesEnabled)
			{
				applied += PluginPatchHelper.Patch(harmony, AccessTools.Method(typeof(ContentDatabase), "GetAllVoiceBundles", (Type[])null, (Type[])null), typeof(CustomVoiceDatabasePatches), null, "GetAllVoiceBundles_Postfix");
				applied += PluginPatchHelper.Patch(harmony, AccessTools.Method(typeof(ContentDatabase), "GetVoiceBundle", (Type[])null, (Type[])null), typeof(CustomVoiceDatabasePatches), "GetVoiceBundle_Prefix");
				applied += PluginPatchHelper.Patch(harmony, AccessTools.Method(typeof(LandfallContentDatabase), "GetVoiceBundle", (Type[])null, (Type[])null), typeof(CustomVoiceDatabasePatches), "GetVoiceBundle_Prefix");
			}
		}

		public static void GetAllVoiceBundles_Postfix(ref IEnumerable<VoiceBundle> __result)
		{
			if (!UnitEditorConfig.CustomVoicesEnabled)
			{
				return;
			}
			List<VoiceBundle> list = new List<VoiceBundle>();
			if (__result != null)
			{
				foreach (VoiceBundle item in __result)
				{
					list.Add(item);
				}
			}
			foreach (VoiceBundle allCustomBundle in CustomVoiceRegistry.AllCustomBundles)
			{
				list.Add(allCustomBundle);
			}
			__result = list;
		}

		public static bool GetVoiceBundle_Prefix(DatabaseID id, ref VoiceBundle __result)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (!UnitEditorConfig.CustomVoicesEnabled)
			{
				return true;
			}
			if (CustomVoiceBundleMarker.TryGetPackId(id, out var packId) && CustomVoiceRegistry.TryGetBundle(packId, out var bundle))
			{
				__result = bundle;
				return false;
			}
			return true;
		}
	}
	internal static class CustomVoiceDeserializePatches
	{
		internal static void Register(Harmony harmony, ref int applied)
		{
			if (UnitEditorConfig.CustomVoicesEnabled)
			{
				applied += PluginPatchHelper.Patch(harmony, AccessTools.Method(typeof(UnitBlueprint), "DeserializedUnit", (Type[])null, (Type[])null), typeof(CustomVoiceDeserializePatches), null, "DeserializedUnit_Postfix");
			}
		}

		public static void DeserializedUnit_Postfix(SerializedUnitBlueprint data, ref UnitBlueprint __result)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (UnitEditorConfig.CustomVoicesEnabled && data != null && !((Object)(object)__result == (Object)null) && CustomVoiceBundleMarker.TryGetPackId(data.voiceBundle, out var packId) && CustomVoiceRegistry.TryGetBundle(packId, out var bundle))
			{
				__result.voiceBundle = bundle;
				string text = packId;
				DatabaseEntity entity = __result.Entity;
				Plugin.LogInfo("Custom voice restored on load: " + text + " for unit " + ((entity != null) ? entity.Name : null));
			}
		}
	}
	internal static class CustomVoiceValidatePatches
	{
		internal static void Register(Harmony harmony, ref int applied)
		{
			if (UnitEditorConfig.CustomVoicesEnabled)
			{
				applied += PluginPatchHelper.Patch(harmony, AccessTools.Method(typeof(UnitBlueprint), "Validate", (Type[])null, (Type[])null), typeof(CustomVoiceValidatePatches), "Validate_Prefix");
			}
		}

		public static bool Validate_Prefix(UnitBlueprint __instance, ref bool __result)
		{
			if (!UnitEditorConfig.CustomVoicesEnabled || (Object)(object)__instance == (Object)null)
			{
				return true;
			}
			if ((Object)(object)__instance.voiceBundle == (Object)null || !CustomVoiceRegistry.IsCustomBundle(__instance.voiceBundle))
			{
				return true;
			}
			string footRef = FootstepBlueprintHelper.GetFootRef(__instance);
			AudioPathData val = null;
			__result = AudioPathData.ValidateAndAssignPathData(footRef, ref val, (Object)(object)__instance);
			FootstepBlueprintHelper.SyncFootPathData(__instance);
			return false;
		}
	}
	internal static class CustomVoiceVoiceSelectPatches
	{
		internal static void Register(Harmony harmony, ref int applied)
		{
			if (UnitEditorConfig.CustomVoicesEnabled)
			{
				applied += PluginPatchHelper.Patch(harmony, AccessTools.Method(typeof(UnitEditorVoiceSelectCell), "Play", (Type[])null, (Type[])null), typeof(CustomVoiceVoiceSelectPatches), "VoiceSelectCell_Play_Prefix");
			}
		}

		public static bool VoiceSelectCell_Play_Prefix(UnitEditorVoiceSelectCell __instance)
		{
			object? obj = AccessTools.Field(typeof(UnitEditorVoiceSelectCell), "voiceBundle")?.GetValue(__instance);
			VoiceBundle val = (VoiceBundle)((obj is VoiceBundle) ? obj : null);
			if (val == null)
			{
				return true;
			}
			if (!CustomVoiceRegistry.TryGetPackByBundle(val, out var pack))
			{
				return true;
			}
			CustomVoicePreview.PlayRandomVocal(pack);
			return false;
		}
	}
	internal static class CustomVoiceUnitPagePreviewPatches
	{
		internal static void Register(Harmony harmony, ref int applied)
		{
			if (UnitEditorConfig.CustomVoicesEnabled)
			{
				applied += PluginPatchHelper.Patch(harmony, AccessTools.Method(typeof(UnitEditorUnitPage), "PlaySound", (Type[])null, (Type[])null), typeof(CustomVoiceUnitPagePreviewPatches), "PlaySound_Prefix");
			}
		}

		public static bool PlaySound_Prefix(UnitEditorUnitPage __instance)
		{
			object? obj = AccessTools.Field(typeof(UnitEditorUnitPage), "voiceBundle")?.GetValue(__instance);
			VoiceBundle val = (VoiceBundle)((obj is VoiceBundle) ? obj : null);
			if (val == null)
			{
				return true;
			}
			if (!CustomVoiceRegistry.TryGetPackByBundle(val, out var pack))
			{
				return true;
			}
			CustomVoicePreview.PlayRandomVocal(pack, __instance.GetPitch());
			return false;
		}
	}
	internal static class CustomVoiceUnitSoundsPatches
	{
		internal static void Register(Harmony harmony, ref int applied)
		{
			if (UnitEditorConfig.CustomVoicesEnabled)
			{
				applied += PluginPatchHelper.Patch(harmony, AccessTools.Method(typeof(UnitSounds), "PlayVocalSound", (Type[])null, (Type[])null), typeof(CustomVoiceUnitSoundsPatches), "PlayVocalSound_Prefix");
				applied += PluginPatchHelper.Patch(harmony, AccessTools.Method(typeof(UnitSounds), "PlayDeathSound", (Type[])null, (Type[])null), typeof(CustomVoiceUnitSoundsPatches), "PlayDeathSound_Prefix");
			}
		}

		public static bool PlayVocalSound_Prefix(UnitSounds __instance, int vocalType, float str, Vector3 pos)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			if (CustomVoiceRuntime.TryPlayCustomVocal(__instance, vocalType, str, pos))
			{
				return false;
			}
			return true;
		}

		public static bool PlayDeathSound_Prefix(UnitSounds __instance, float str, Vector3 pos)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			if (CustomVoiceRuntime.TryPlayCustomDeath(__instance, str, pos))
			{
				return false;
			}
			return true;
		}
	}
	internal static class CustomVoiceUnitButtonPatches
	{
		private static FieldInfo _unitIdField;

		private static FieldInfo _camTransformField;

		internal static void Register(Harmony harmony, ref int applied)
		{
			if (UnitEditorConfig.CustomVoicesEnabled)
			{
				MethodInfo original = AccessTools.Method(typeof(UnitButton), "SelectUnit", new Type[1] { typeof(bool) }, (Type[])null);
				applied += PluginPatchHelper.Patch(harmony, original, typeof(CustomVoiceUnitButtonPatches), "SelectUnit_Prefix");
			}
		}

		public static void SelectUnit_Prefix(UnitButton __instance, ref bool makeSound)
		{
			//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_007d: 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_00ae: 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)
			if (!makeSound || !UnitEditorConfig.CustomVoicesEnabled)
			{
				return;
			}
			if ((object)_unitIdField == null)
			{
				_unitIdField = AccessTools.Field(typeof(UnitButton), "m_unitID");
			}
			if ((object)_camTransformField == null)
			{
				_camTransformField = AccessTools.Field(typeof(SimpleButton), "m_mainCamTransform");
			}
			object obj = _unitIdField?.GetValue(__instance);
			if (!(obj is DatabaseID))
			{
				return;
			}
			DatabaseID val = (DatabaseID)obj;
			ContentDatabase obj2 = ContentDatabase.Instance();
			UnitBlueprint val2 = ((obj2 != null) ? obj2.GetUnitBlueprint(val) : null);
			if (!((Object)(object)val2?.voiceBundle == (Object)null) && CustomVoiceRegistry.TryGetPackByBundle(val2.voiceBundle, out var _))
			{
				Vector3 pos = ResolvePreviewPosition(__instance);
				if (CustomVoiceRuntime.TryPlayBlueprintVocal(val2, pos))
				{
					makeSound = false;
				}
			}
		}

		private static Vector3 ResolvePreviewPosition(UnitButton instance)
		{
			//IL_0075: 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_0060: 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_0025: 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)
			object? obj = _camTransformField?.GetValue(instance);
			Transform val = (Transform)((obj is Transform) ? obj : null);
			if (val != null && (Object)(object)val != (Object)null)
			{
				return val.position + val.forward * 25f;
			}
			Camera main = Camera.main;
			if ((Object)(object)main != (Object)null)
			{
				return ((Component)main).transform.position + ((Component)main).transform.forward * 25f;
			}
			return Vector3.zero;
		}
	}
	internal static class CustomVoiceSpawnPatches
	{
		internal static void Register(Harmony harmony, ref int applied)
		{
			if (!UnitEditorConfig.CustomVoicesEnabled)
			{
				return;
			}
			foreach (MethodInfo declaredMethod in AccessTools.GetDeclaredMethods(typeof(UnitBlueprint)))
			{
				if (!(declaredMethod.Name != "Spawn"))
				{
					ParameterInfo[] parameters = declaredMethod.GetParameters();
					if (parameters.Length >= 4 && parameters[3].ParameterType.IsByRef)
					{
						applied += PluginPatchHelper.Patch(harmony, declaredMethod, typeof(CustomVoiceSpawnPatches), null, "Spawn_Postfix");
						break;
					}
				}
			}
		}

		public static void Spawn_Postfix(UnitBlueprint __instance, ref Unit unitToSpawn)
		{
			if (!((Object)(object)unitToSpawn == (Object)null) && !((Object)(object)__instance?.voiceBundle == (Object)null))
			{
				CustomVoiceRuntime.RegisterUnit(unitToSpawn, __instance.voiceBundle);
			}
		}
	}
	internal static class PluginPatchHelper
	{
		internal static int Patch(Harmony harmony, MethodBase original, Type patchClass, string prefix = null, string postfix = null)
		{
			//IL_0017: 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)
			if (original == null)
			{
				return 0;
			}
			try
			{
				object obj = harmony;
				obj = original;
				obj = (object)((prefix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(patchClass, prefix, (Type[])null));
				obj = (object)((postfix == null) ? ((HarmonyMethod)null) : new HarmonyMethod(patchClass, postfix, (Type[])null));
				((Harmony)obj).Patch((MethodBase)obj, (HarmonyMethod)obj, (HarmonyMethod)obj, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				return 1;
			}
			catch (Exception ex)
			{
				Plugin.LogWarning("Custom voice patch failed for " + original.Name + ": " + ex.Message);
				return 0;
			}
		}
	}
	internal static class CustomVoiceStore
	{
		private static readonly List<CustomVoicePack> CachedPacks = new List<CustomVoicePack>();

		internal static IReadOnlyList<CustomVoicePack> AllPacks => CachedPacks;

		internal static void LoadAll()
		{
			CustomVoicePaths.EnsureDirectories();
			CachedPacks.Clear();
			if (!Directory.Exists(CustomVoicePaths.PacksDirectory))
			{
				return;
			}
			string[] files = Directory.GetFiles(CustomVoicePaths.PacksDirectory, "*.json");
			foreach (string path in files)
			{
				try
				{
					CustomVoicePack customVoicePack = JsonConvert.DeserializeObject<CustomVoicePack>(File.ReadAllText(path));
					if (customVoicePack != null && !string.IsNullOrEmpty(customVoicePack.id))
					{
						customVoicePack.Sanitize();
						CachedPacks.Add(customVoicePack);
					}
				}
				catch (Exception ex)
				{
					Plugin.LogWarning("Custom voice: failed to load " + Path.GetFileName(path) + ": " + ex.Message);
				}
			}
			CachedPacks.Sort((CustomVoicePack a, CustomVoicePack b) => string.Compare(a.name, b.name, StringComparison.OrdinalIgnoreCase));
		}

		internal static CustomVoicePack GetById(string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				return null;
			}
			for (int i = 0; i < CachedPacks.Count; i++)
			{
				if (string.Equals(CachedPacks[i].id, id, StringComparison.OrdinalIgnoreCase))
				{
					return CachedPacks[i];
				}
			}
			return null;
		}

		internal static void Save(CustomVoicePack pack)
		{
			if (pack != null)
			{
				pack.Sanitize();
				CustomVoicePaths.EnsureDirectories();
				File.WriteAllText(PackFilePath(pack.id), JsonConvert.SerializeObject((object)pack, (Formatting)1));
				LoadAll();
				CustomVoiceRegistry.RefreshFromStore();
			}
		}

		internal static void Delete(string packId)
		{
			if (!string.IsNullOrEmpty(packId))
			{
				string path = PackFilePath(packId);
				if (File.Exists(path))
				{
					File.Delete(path);
				}
				LoadAll();
				CustomVoiceRegistry.RefreshFromStore();
			}
		}

		internal static int RemoveFileFromAllPacks(string fileName)
		{
			if (string.IsNullOrEmpty(fileName))
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < CachedPacks.Count; i++)
			{
				CustomVoicePack customVoicePack = CachedPacks[i];
				if (customVoicePack != null && PackReferencesFile(customVoicePack, fileName))
				{
					CustomVoicePack customVoicePack2 = customVoicePack.Clone();
					RemoveMatchingFile(customVoicePack2.vocalFiles, fileName);
					RemoveMatchingFile(customVoicePack2.deathFiles, fileName);
					Save(customVoicePack2);
					num++;
				}
			}
			return num;
		}

		internal static int PurgeIneligibleFromSavedPacks(Func<string, bool> isEligible)
		{
			if (isEligible == null)
			{
				return 0;
			}
			List<CustomVoicePack> list = new List<CustomVoicePack>();
			for (int i = 0; i < CachedPacks.Count; i++)
			{
				CustomVoicePack customVoicePack = CachedPacks[i];
				if (customVoicePack != null)
				{
					CustomVoicePack customVoicePack2 = customVoicePack.Clone();
					int num = customVoicePack2.vocalFiles?.Count ?? 0;
					int num2 = customVoicePack2.deathFiles?.Count ?? 0;
					customVoicePack2.vocalFiles = FilterEligibleList(customVoicePack2.vocalFiles, isEligible);
					customVoicePack2.deathFiles = FilterEligibleList(customVoicePack2.deathFiles, isEligible);
					if ((customVoicePack2.vocalFiles?.Count ?? 0) != num || (customVoicePack2.deathFiles?.Count ?? 0) != num2)
					{
						list.Add(customVoicePack2);
					}
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				Save(list[j]);
			}
			return list.Count;
		}

		private static List<string> FilterEligibleList(List<string> files, Func<string, bool> isEligible)
		{
			List<string> list = new List<string>();
			if (files == null)
			{
				return list;
			}
			for (int i = 0; i < files.Count; i++)
			{
				string fileName = Path.GetFileName(files[i]?.Trim());
				if (!string.IsNullOrEmpty(fileName) && isEligible(fileName))
				{
					list.Add(fileName);
				}
			}
			return list;
		}

		private static bool PackReferencesFile(CustomVoicePack pack, string fileName)
		{
			if (!ContainsFile(pack.vocalFiles, fileName))
			{
				return ContainsFile(pack.deathFiles, fileName);
			}
			return true;
		}

		private static bool ContainsFile(List<string> files, string fileName)
		{
			if (files == null)
			{
				return false;
			}
			for (int i = 0; i < files.Count; i++)
			{
				if (string.Equals(Path.GetFileName(files[i]?.Trim()), fileName, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static bool RemoveMatchingFile(List<string> files, string fileName)
		{
			if (files == null || files.Count == 0)
			{
				return false;
			}
			return files.RemoveAll((string entry) => string.Equals(Path.GetFileName(entry?.Trim()), fileName, StringComparison.OrdinalIgnoreCase)) > 0;
		}

		private static string PackFilePath(string packId)
		{
			return Path.Combine(CustomVoicePaths.PacksDirectory, packId + ".json");
		}
	}
}