using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using Microsoft.CodeAnalysis;
using UnityEngine;

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace HowToFish.BossMaker
{
	public enum BossActionKind
	{
		StatMultiplier,
		SpawnMinions,
		ToggleVisualNode,
		SetVisualScale,
		PlayAudio,
		SpawnVisualEffect,
		AreaDamage,
		Force,
		Dash
	}
	public abstract class BossActionDefinition
	{
		public abstract BossActionKind Kind { get; }

		public string Id { get; set; } = string.Empty;
	}
	public sealed class StatMultiplierAction : BossActionDefinition
	{
		public override BossActionKind Kind => BossActionKind.StatMultiplier;

		public float? DamageMultiplier { get; set; }

		public float? MovementSpeedMultiplier { get; set; }

		public float? AttackCooldownMultiplier { get; set; }

		public float? DashForceMultiplier { get; set; }

		public float? DashIntervalMultiplier { get; set; }

		public string ModifierId { get; set; } = string.Empty;

		public BossModifierLifetime Lifetime { get; set; }

		public float DurationSeconds { get; set; }
	}
	public sealed class SpawnMinionsAction : BossActionDefinition
	{
		public override BossActionKind Kind => BossActionKind.SpawnMinions;

		public string? TemplateName { get; set; }

		public string? RegisteredBossId { get; set; }

		public int Count { get; set; } = 1;

		public float SpawnRadius { get; set; } = 4f;

		public int MaxAliveFromThisAction { get; set; } = 1;

		public string GroupId { get; set; } = "default";

		public MinionCleanupPolicy CleanupPolicy { get; set; } = MinionCleanupPolicy.Persist;

		public float LifetimeSeconds { get; set; }

		public BossPlacementDefinition? Placement { get; set; }

		public BossFormationDefinition? Formation { get; set; }
	}
	public sealed class ToggleVisualNodeAction : BossActionDefinition
	{
		public override BossActionKind Kind => BossActionKind.ToggleVisualNode;

		public string RelativeTransformPath { get; set; } = string.Empty;

		public bool Enabled { get; set; } = true;

		public bool Persistent { get; set; } = true;
	}
	public sealed class SetVisualScaleAction : BossActionDefinition
	{
		public override BossActionKind Kind => BossActionKind.SetVisualScale;

		public float ScaleMultiplier { get; set; } = 1f;

		public bool Persistent { get; set; } = true;
	}
	public sealed class PlayAudioAction : BossActionDefinition
	{
		public override BossActionKind Kind => BossActionKind.PlayAudio;

		public AudioClip? Clip { get; set; }

		public float Volume { get; set; } = 1f;

		public float SpatialBlend { get; set; } = 1f;
	}
	public enum BossVisualEffectAnchor
	{
		Boss,
		AbilityOrigin,
		TargetPosition,
		AbilityEndpoint
	}
	public sealed class SpawnVisualEffectAction : BossActionDefinition
	{
		public override BossActionKind Kind => BossActionKind.SpawnVisualEffect;

		public GameObject? Prefab { get; set; }

		public BossVisualEffectAnchor Anchor { get; set; }

		public bool ParentToBoss { get; set; } = true;

		public bool AlignToAbilityDirection { get; set; }

		public Vector3 LocalOffset { get; set; } = Vector3.zero;

		public Vector3 LocalEulerAngles { get; set; } = Vector3.zero;

		public Vector3 LocalScale { get; set; } = Vector3.one;

		public float Lifetime { get; set; } = 5f;
	}
	public enum MinionCleanupPolicy
	{
		DespawnOnBossDefeat,
		DespawnOnOwnerDespawn,
		DespawnOnPhaseExit,
		Persist
	}
	public sealed class AreaDamageAction : BossActionDefinition
	{
		public override BossActionKind Kind => BossActionKind.AreaDamage;

		public int Damage { get; set; } = 1;

		public float DurationSeconds { get; set; }

		public float TickIntervalSeconds { get; set; }

		public int MaxHitsPerTarget { get; set; } = 1;

		public float VerticalTolerance { get; set; } = 4f;
	}
	public enum BossForceMode
	{
		Push,
		Pull,
		Directional
	}
	public sealed class ForceAction : BossActionDefinition
	{
		public override BossActionKind Kind => BossActionKind.Force;

		public BossForceMode Mode { get; set; }

		public float Magnitude { get; set; } = 5f;

		public float DurationSeconds { get; set; }

		public float VerticalTolerance { get; set; } = 4f;

		public float VerticalMultiplier { get; set; } = 1f;

		public float MaximumVelocityChange { get; set; } = 20f;
	}
	public sealed class DashAction : BossActionDefinition
	{
		public override BossActionKind Kind => BossActionKind.Dash;

		public float Impulse { get; set; } = 16f;

		public float VerticalImpulse { get; set; }

		public float RetainedVelocityFraction { get; set; } = 0.15f;

		public float MaximumSpeed { get; set; } = 40f;

		public float MaximumTravelDistance { get; set; }

		public float StoppingDistance { get; set; }

		public float BrakeDurationSeconds { get; set; }

		public float ExitVelocityFraction { get; set; } = 1f;
	}
	public enum BossActionExecutionStatus
	{
		Applied,
		Skipped,
		Failed
	}
	public enum BossActionResultCode
	{
		Succeeded,
		IdempotentReplay,
		NoEligibleTargets,
		BudgetExceeded,
		CapabilityUnavailable,
		PlacementUnavailable,
		AuthorityRequired,
		InvalidContext,
		Cancelled,
		ExecutionFailed
	}
	public sealed class BossActionResultSnapshot
	{
		public string EncounterId { get; }

		public string BossId { get; }

		public string ActionId { get; }

		public BossActionKind ActionKind { get; }

		public int ActionOrdinal { get; }

		public long Sequence { get; }

		public long ServerTick { get; }

		public double ServerTime { get; }

		public BossActionExecutionStatus Status { get; }

		public BossActionResultCode Code { get; }

		public int AttemptedTargets { get; }

		public int AffectedTargets { get; }

		public int SpawnedEntities { get; }

		public string? PhaseId { get; }

		public string? AbilityId { get; }

		public string Message { get; }

		public bool Succeeded => Status == BossActionExecutionStatus.Applied;

		public BossActionResultSnapshot(string encounterId, string bossId, string actionId, BossActionKind actionKind, int actionOrdinal, long sequence, long serverTick, double serverTime, BossActionExecutionStatus status, BossActionResultCode code, int attemptedTargets = 0, int affectedTargets = 0, int spawnedEntities = 0, string? phaseId = null, string? abilityId = null, string? message = null)
		{
			EncounterIdValidationResult encounterIdValidationResult = EncounterIdValidator.Validate(encounterId);
			if (!encounterIdValidationResult.IsValid)
			{
				throw new ArgumentException(encounterIdValidationResult.Message, "encounterId");
			}
			if (!BossDefinitionValidator.IsValidBossId(bossId))
			{
				throw new ArgumentException("BossId must be a normalized namespaced boss ID.", "bossId");
			}
			EncounterContractValidation.RequireSafeToken(actionId, "actionId", 128);
			if (!Enum.IsDefined(typeof(BossActionKind), actionKind))
			{
				throw new ArgumentOutOfRangeException("actionKind");
			}
			if (actionOrdinal < 0 || actionOrdinal >= 32)
			{
				throw new ArgumentOutOfRangeException("actionOrdinal");
			}
			if (sequence < 0)
			{
				throw new ArgumentOutOfRangeException("sequence");
			}
			if (serverTick < 0)
			{
				throw new ArgumentOutOfRangeException("serverTick");
			}
			if (!EncounterContractValidation.IsFinite(serverTime) || serverTime < 0.0)
			{
				throw new ArgumentOutOfRangeException("serverTime");
			}
			if (!Enum.IsDefined(typeof(BossActionExecutionStatus), status))
			{
				throw new ArgumentOutOfRangeException("status");
			}
			if (!Enum.IsDefined(typeof(BossActionResultCode), code))
			{
				throw new ArgumentOutOfRangeException("code");
			}
			if (attemptedTargets < 0 || attemptedTargets > 1024 || affectedTargets < 0 || affectedTargets > attemptedTargets || spawnedEntities < 0 || spawnedEntities > 1024)
			{
				throw new ArgumentOutOfRangeException("attemptedTargets", "Action result counts are inconsistent or exceed their bound.");
			}
			if (phaseId != null)
			{
				EncounterContractValidation.RequireSafeToken(phaseId, "phaseId", 128);
			}
			if (abilityId != null)
			{
				EncounterContractValidation.RequireSafeToken(abilityId, "abilityId", 128);
			}
			if (message != null && message.Length > 1024)
			{
				throw new ArgumentOutOfRangeException("message");
			}
			EncounterId = encounterId;
			BossId = bossId;
			ActionId = actionId;
			ActionKind = actionKind;
			ActionOrdinal = actionOrdinal;
			Sequence = sequence;
			ServerTick = serverTick;
			ServerTime = serverTime;
			Status = status;
			Code = code;
			AttemptedTargets = attemptedTargets;
			AffectedTargets = affectedTargets;
			SpawnedEntities = spawnedEntities;
			PhaseId = phaseId;
			AbilityId = abilityId;
			Message = message ?? string.Empty;
		}
	}
	public enum BossModifierLifetime
	{
		Permanent,
		UntilPhaseExit,
		UntilAbilityEnd,
		Timed
	}
	public sealed class BossActiveModifierSnapshot
	{
		public string ModifierId { get; }

		public string SourceActionId { get; }

		public long SourceSequence { get; }

		public BossModifierLifetime Lifetime { get; }

		public float? DamageMultiplier { get; }

		public float? MovementSpeedMultiplier { get; }

		public float? AttackCooldownMultiplier { get; }

		public float? DashForceMultiplier { get; }

		public float? DashIntervalMultiplier { get; }

		public string? PhaseId { get; }

		public string? AbilityId { get; }

		public double? ExpiresAtServerTime { get; }

		public BossActiveModifierSnapshot(string modifierId, string sourceActionId, long sourceSequence, BossModifierLifetime lifetime, float? damageMultiplier, float? movementSpeedMultiplier, float? attackCooldownMultiplier, string? phaseId = null, string? abilityId = null, double? expiresAtServerTime = null)
			: this(modifierId, sourceActionId, sourceSequence, lifetime, damageMultiplier, movementSpeedMultiplier, attackCooldownMultiplier, null, null, phaseId, abilityId, expiresAtServerTime)
		{
		}

		public BossActiveModifierSnapshot(string modifierId, string sourceActionId, long sourceSequence, BossModifierLifetime lifetime, float? damageMultiplier, float? movementSpeedMultiplier, float? attackCooldownMultiplier, float? dashForceMultiplier, float? dashIntervalMultiplier, string? phaseId = null, string? abilityId = null, double? expiresAtServerTime = null)
		{
			EncounterContractValidation.RequireSafeToken(modifierId, "modifierId", 128);
			EncounterContractValidation.RequireSafeToken(sourceActionId, "sourceActionId", 128);
			if (!Enum.IsDefined(typeof(BossModifierLifetime), lifetime))
			{
				throw new ArgumentOutOfRangeException("lifetime");
			}
			if (lifetime == BossModifierLifetime.Permanent)
			{
				throw new ArgumentException("Active modifier snapshots represent reversible layers and cannot use Permanent lifetime.", "lifetime");
			}
			if (sourceSequence < 0)
			{
				throw new ArgumentOutOfRangeException("sourceSequence");
			}
			ValidateMultiplier(damageMultiplier, "damageMultiplier");
			ValidateMultiplier(movementSpeedMultiplier, "movementSpeedMultiplier");
			ValidateMultiplier(attackCooldownMultiplier, "attackCooldownMultiplier");
			ValidateMultiplier(dashForceMultiplier, "dashForceMultiplier");
			ValidateMultiplier(dashIntervalMultiplier, "dashIntervalMultiplier");
			if (!damageMultiplier.HasValue && !movementSpeedMultiplier.HasValue && !attackCooldownMultiplier.HasValue && !dashForceMultiplier.HasValue && !dashIntervalMultiplier.HasValue)
			{
				throw new ArgumentException("An active modifier must change at least one supported multiplier.", "damageMultiplier");
			}
			if (phaseId != null)
			{
				EncounterContractValidation.RequireSafeToken(phaseId, "phaseId", 128);
			}
			if (abilityId != null)
			{
				EncounterContractValidation.RequireSafeToken(abilityId, "abilityId", 128);
			}
			if (expiresAtServerTime.HasValue && (!EncounterContractValidation.IsFinite(expiresAtServerTime.Value) || expiresAtServerTime.Value < 0.0))
			{
				throw new ArgumentOutOfRangeException("expiresAtServerTime");
			}
			if (lifetime == BossModifierLifetime.Timed != expiresAtServerTime.HasValue)
			{
				throw new ArgumentException("Timed modifiers require an expiry; other lifetimes cannot carry one.", "expiresAtServerTime");
			}
			if (lifetime == BossModifierLifetime.UntilPhaseExit && phaseId == null)
			{
				throw new ArgumentException("UntilPhaseExit modifiers require an owning PhaseId.", "phaseId");
			}
			if (lifetime == BossModifierLifetime.UntilAbilityEnd && (abilityId == null || sourceSequence <= 0))
			{
				throw new ArgumentException("UntilAbilityEnd modifiers require an owning AbilityId and positive source sequence.", "abilityId");
			}
			ModifierId = modifierId;
			SourceActionId = sourceActionId;
			SourceSequence = sourceSequence;
			Lifetime = lifetime;
			DamageMultiplier = damageMultiplier;
			MovementSpeedMultiplier = movementSpeedMultiplier;
			AttackCooldownMultiplier = attackCooldownMultiplier;
			DashForceMultiplier = dashForceMultiplier;
			DashIntervalMultiplier = dashIntervalMultiplier;
			PhaseId = phaseId;
			AbilityId = abilityId;
			ExpiresAtServerTime = expiresAtServerTime;
		}

		private static void ValidateMultiplier(float? value, string parameterName)
		{
			if (value.HasValue && (float.IsNaN(value.Value) || float.IsInfinity(value.Value) || value.Value < 0.01f || value.Value > 100f))
			{
				throw new ArgumentOutOfRangeException(parameterName);
			}
		}
	}
	internal static class PhaseActionIdentity
	{
		internal const int MaximumEncounterIdLength = 256;

		private const int OrdinalBits = 5;

		private const uint OrdinalMask = 31u;

		internal static int CreateActionSeed(int parentSeed, string phaseId, int actionOrdinal)
		{
			ValidatePhaseId(phaseId);
			ValidateActionOrdinal(actionOrdinal);
			return (int)(CreateScope(parentSeed, phaseId) & 0x7FFFFFE0) | actionOrdinal;
		}

		internal static int CreateMinionSeed(int parentSeed, string phaseId, int actionOrdinal, int minionIndex)
		{
			ValidatePhaseId(phaseId);
			ValidateActionOrdinal(actionOrdinal);
			ValidateMinionIndex(minionIndex);
			uint num = CreateScope(parentSeed, phaseId);
			uint num2 = (uint)((actionOrdinal << 5) | minionIndex);
			return (int)((num & 0x7FFFFC00) | num2);
		}

		internal static string CreateMinionEncounterId(string parentEncounterId, string bossId, string phaseId, int actionOrdinal, int minionIndex)
		{
			if (parentEncounterId == null)
			{
				throw new ArgumentNullException("parentEncounterId");
			}
			if (bossId == null)
			{
				throw new ArgumentNullException("bossId");
			}
			ValidatePhaseId(phaseId);
			ValidateActionOrdinal(actionOrdinal);
			ValidateMinionIndex(minionIndex);
			string text = actionOrdinal.ToString(CultureInfo.InvariantCulture);
			string text2 = minionIndex.ToString(CultureInfo.InvariantCulture);
			string text3 = parentEncounterId + ":" + phaseId + ":minion:a" + text + ":i" + text2;
			if (text3.Length <= 256)
			{
				return text3;
			}
			string text4 = DeterministicIdentityAllocator.Fnv1A(text3).ToString("x8", CultureInfo.InvariantCulture);
			string text5 = ":minion:" + text4 + ":a" + text + ":i" + text2;
			return bossId[..Math.Min(bossId.Length, 256 - text5.Length)] + text5;
		}

		private static uint CreateScope(int parentSeed, string phaseId)
		{
			uint num = ((uint)parentSeed ^ DeterministicIdentityAllocator.Fnv1A(phaseId) ^ 0x9E3779B9u) * 16777619;
			return num ^ (num >> 16);
		}

		private static void ValidatePhaseId(string phaseId)
		{
			if (string.IsNullOrEmpty(phaseId))
			{
				throw new ArgumentException("A phase ID is required.", "phaseId");
			}
		}

		private static void ValidateActionOrdinal(int actionOrdinal)
		{
			if (actionOrdinal < 0 || actionOrdinal >= 32 || (uint)actionOrdinal > 31u)
			{
				throw new ArgumentOutOfRangeException("actionOrdinal");
			}
		}

		private static void ValidateMinionIndex(int minionIndex)
		{
			if (minionIndex < 0 || minionIndex >= 32 || (uint)minionIndex > 31u)
			{
				throw new ArgumentOutOfRangeException("minionIndex");
			}
		}
	}
	public static class BossMakerMetadata
	{
		public const string ProductName = "BossMakerAPI";

		public const string AssemblyName = "BossMakerAPI";

		public const string PublicNamespace = "HowToFish.BossMaker";

		public const string PluginGuid = "com.skylin3.howtofish.bossmakerapi";

		public const string Version = "0.10.3";

		public const string TargetFramework = "netstandard2.1";
	}
	public enum BossAbilityTrigger
	{
		PhaseEnter,
		OnSpawn,
		AfterDelay,
		Interval,
		Reactive
	}
	public enum BossReactiveRearmPolicy
	{
		AfterFalse,
		AfterCooldownWhileTrue
	}
	public enum BossTargetSelectorKind
	{
		BossPosition,
		NearestPlayer,
		FarthestPlayer,
		RandomPlayer
	}
	public enum BossAbilityGeometryKind
	{
		Circle,
		Ring,
		Line,
		Cone
	}
	public sealed class BossAbilityTimelineDefinition
	{
		public float TelegraphDurationSeconds { get; set; } = 1f;

		public float ResolveDurationSeconds { get; set; }

		public float RecoveryDurationSeconds { get; set; }
	}
	public sealed class BossTelegraphDefinition
	{
		public bool Enabled { get; set; } = true;

		public Color Color { get; set; } = new Color(1f, 0.15f, 0.05f, 0.65f);

		public Color BorderColor { get; set; } = new Color(1f, 0.8f, 0.2f, 1f);

		public float BorderWidth { get; set; } = 0.08f;

		public float PulseFrequency { get; set; } = 1f;

		public bool UseColorBlindPattern { get; set; }

		public AudioClip? AudioClip { get; set; }

		public float AudioVolume { get; set; } = 1f;
	}
	public sealed class BossTargetSelectorDefinition
	{
		public BossTargetSelectorKind Kind { get; set; }

		public float MaximumRange { get; set; }

		public bool LockPositionAtTelegraph { get; set; } = true;

		public float LockBeforeResolveSeconds { get; set; }
	}
	public abstract class BossAbilityGeometryDefinition
	{
		public abstract BossAbilityGeometryKind Kind { get; }

		public Vector3 LocalOffset { get; set; } = Vector3.zero;
	}
	public sealed class CircleGeometryDefinition : BossAbilityGeometryDefinition
	{
		public override BossAbilityGeometryKind Kind => BossAbilityGeometryKind.Circle;

		public float Radius { get; set; } = 4f;
	}
	public sealed class RingGeometryDefinition : BossAbilityGeometryDefinition
	{
		public override BossAbilityGeometryKind Kind => BossAbilityGeometryKind.Ring;

		public float InnerRadius { get; set; } = 2f;

		public float OuterRadius { get; set; } = 5f;
	}
	public sealed class LineGeometryDefinition : BossAbilityGeometryDefinition
	{
		public override BossAbilityGeometryKind Kind => BossAbilityGeometryKind.Line;

		public float Length { get; set; } = 8f;

		public float Width { get; set; } = 1f;
	}
	public sealed class ConeGeometryDefinition : BossAbilityGeometryDefinition
	{
		public override BossAbilityGeometryKind Kind => BossAbilityGeometryKind.Cone;

		public float Radius { get; set; } = 7f;

		public float AngleDegrees { get; set; } = 60f;
	}
	public sealed class BossAbilityDefinition
	{
		public string Id { get; set; } = string.Empty;

		public BossAbilityTrigger Trigger { get; set; }

		public float InitialDelaySeconds { get; set; }

		public float CooldownSeconds { get; set; }

		public int MaxRepeats { get; set; }

		public float Probability { get; set; } = 1f;

		public BossConditionDefinition? Condition { get; set; }

		public BossReactiveRearmPolicy ReactiveRearmPolicy { get; set; }

		public BossAbilityTimelineDefinition Timeline { get; set; } = new BossAbilityTimelineDefinition();

		public BossTargetSelectorDefinition TargetSelector { get; set; } = new BossTargetSelectorDefinition();

		public BossAbilityGeometryDefinition Geometry { get; set; } = new CircleGeometryDefinition();

		public BossTelegraphDefinition Telegraph { get; set; } = new BossTelegraphDefinition();

		public IReadOnlyList<BossActionDefinition> Actions { get; set; } = Array.Empty<BossActionDefinition>();
	}
	public enum BossConditionKind
	{
		Health,
		DamageTaken,
		PlayerDistance,
		MinionCount,
		MinionDefeated,
		AbilityCompleted,
		TimeInPhase,
		BossHooked,
		All,
		Any,
		Not
	}
	public enum BossNumericComparison
	{
		LessThan,
		LessThanOrEqual,
		Equal,
		GreaterThanOrEqual,
		GreaterThan,
		NotEqual
	}
	public enum BossConditionScope
	{
		Encounter,
		ActivePhase,
		RollingWindow
	}
	public abstract class BossConditionDefinition
	{
		public abstract BossConditionKind Kind { get; }
	}
	public sealed class BossHealthConditionDefinition : BossConditionDefinition
	{
		public override BossConditionKind Kind => BossConditionKind.Health;

		public BossNumericComparison Comparison { get; set; } = BossNumericComparison.LessThanOrEqual;

		public float HealthFraction { get; set; } = 0.5f;
	}
	public sealed class BossDamageTakenConditionDefinition : BossConditionDefinition
	{
		public override BossConditionKind Kind => BossConditionKind.DamageTaken;

		public BossNumericComparison Comparison { get; set; } = BossNumericComparison.GreaterThanOrEqual;

		public int Damage { get; set; } = 1;

		public BossConditionScope Scope { get; set; } = BossConditionScope.ActivePhase;

		public float WindowSeconds { get; set; }
	}
	public sealed class BossPlayerDistanceConditionDefinition : BossConditionDefinition
	{
		public override BossConditionKind Kind => BossConditionKind.PlayerDistance;

		public BossNumericComparison Comparison { get; set; } = BossNumericComparison.LessThanOrEqual;

		public float Distance { get; set; } = 10f;

		public int RequiredPlayerCount { get; set; } = 1;
	}
	public sealed class BossMinionCountConditionDefinition : BossConditionDefinition
	{
		public override BossConditionKind Kind => BossConditionKind.MinionCount;

		public string? GroupId { get; set; }

		public BossNumericComparison Comparison { get; set; } = BossNumericComparison.LessThanOrEqual;

		public int Count { get; set; }
	}
	public sealed class BossMinionDefeatedConditionDefinition : BossConditionDefinition
	{
		public override BossConditionKind Kind => BossConditionKind.MinionDefeated;

		public string? GroupId { get; set; }

		public BossNumericComparison Comparison { get; set; } = BossNumericComparison.GreaterThanOrEqual;

		public int Count { get; set; } = 1;

		public BossConditionScope Scope { get; set; } = BossConditionScope.ActivePhase;

		public float WindowSeconds { get; set; }
	}
	public sealed class BossAbilityCompletedConditionDefinition : BossConditionDefinition
	{
		public override BossConditionKind Kind => BossConditionKind.AbilityCompleted;

		public string AbilityId { get; set; } = string.Empty;

		public BossNumericComparison Comparison { get; set; } = BossNumericComparison.GreaterThanOrEqual;

		public int Count { get; set; } = 1;

		public BossConditionScope Scope { get; set; } = BossConditionScope.ActivePhase;

		public float WindowSeconds { get; set; }
	}
	public sealed class BossTimeInPhaseConditionDefinition : BossConditionDefinition
	{
		public override BossConditionKind Kind => BossConditionKind.TimeInPhase;

		public BossNumericComparison Comparison { get; set; } = BossNumericComparison.GreaterThanOrEqual;

		public float Seconds { get; set; } = 1f;
	}
	public sealed class BossHookedConditionDefinition : BossConditionDefinition
	{
		public override BossConditionKind Kind => BossConditionKind.BossHooked;

		public BossHookLifecycleState? RequiredState { get; set; } = BossHookLifecycleState.Hooked;

		public float MinimumContinuousSeconds { get; set; }
	}
	public sealed class BossAllConditionDefinition : BossConditionDefinition
	{
		public override BossConditionKind Kind => BossConditionKind.All;

		public IReadOnlyList<BossConditionDefinition> Conditions { get; set; } = Array.Empty<BossConditionDefinition>();
	}
	public sealed class BossAnyConditionDefinition : BossConditionDefinition
	{
		public override BossConditionKind Kind => BossConditionKind.Any;

		public IReadOnlyList<BossConditionDefinition> Conditions { get; set; } = Array.Empty<BossConditionDefinition>();
	}
	public sealed class BossNotConditionDefinition : BossConditionDefinition
	{
		public override BossConditionKind Kind => BossConditionKind.Not;

		public BossConditionDefinition? Condition { get; set; }
	}
	public sealed class BossDefinition
	{
		public string Id { get; set; } = string.Empty;

		public string ContentVersion { get; set; } = "1.0.0";

		public string DisplayName { get; set; } = string.Empty;

		public string Template { get; set; } = string.Empty;

		public BossVisualDefinition Visual { get; set; } = new BossVisualDefinition();

		public BossStatOverrides Stats { get; set; } = new BossStatOverrides();

		public IReadOnlyList<BossAbilityDefinition> Abilities { get; set; } = Array.Empty<BossAbilityDefinition>();

		public IReadOnlyList<BossPhaseDefinition> Phases { get; set; } = Array.Empty<BossPhaseDefinition>();

		public IReadOnlyList<BossRewardDefinition> Rewards { get; set; } = Array.Empty<BossRewardDefinition>();

		public RewardPolicy RewardPolicy { get; set; }

		public BossEncounterDefinition Encounter { get; set; } = new BossEncounterDefinition();

		public BossPersistenceDefinition Persistence { get; set; } = new BossPersistenceDefinition();

		public BossVanillaIntegrationDefinition VanillaIntegration { get; set; } = new BossVanillaIntegrationDefinition();

		public bool ShowBossBar { get; set; } = true;

		public bool Live { get; internal set; }

		public string FailureMessage { get; internal set; } = string.Empty;
	}
	public sealed class BossVisualDefinition
	{
		public GameObject? Prefab { get; set; }

		public Vector3 LocalPosition { get; set; } = Vector3.zero;

		public Vector3 LocalEulerAngles { get; set; } = Vector3.zero;

		public Vector3 LocalScale { get; set; } = Vector3.one;

		public bool DisableTemplateRenderers { get; set; }

		public bool RemoveVisualColliders { get; set; } = true;

		public string AssetIdentity { get; set; } = string.Empty;

		public string DeclaredAssetDigest { get; set; } = string.Empty;
	}
	public sealed class BossStatOverrides
	{
		public int? MaxHealth { get; set; }

		public float? DamageMultiplier { get; set; }

		public float? MovementSpeedMultiplier { get; set; }

		public float? AttackCooldownMultiplier { get; set; }

		public float? DashForceMultiplier { get; set; }

		public float? DashIntervalMultiplier { get; set; }

		public float? KnockbackResistanceMultiplier { get; set; }

		public float? MassMultiplier { get; set; }

		public float? ScaleMultiplier { get; set; }

		public float? VanillaCorpseValueMultiplier { get; set; }
	}
	public sealed class BossPhaseDefinition
	{
		public string Id { get; set; } = string.Empty;

		public string? DisplayName { get; set; }

		public float TriggerHealthFraction { get; set; }

		public IReadOnlyList<BossActionDefinition> Actions { get; set; } = Array.Empty<BossActionDefinition>();

		public IReadOnlyList<BossActionDefinition> ExitActions { get; set; } = Array.Empty<BossActionDefinition>();

		public IReadOnlyList<BossAbilityDefinition> Abilities { get; set; } = Array.Empty<BossAbilityDefinition>();

		public BossPhaseGateDefinition Gate { get; set; } = new BossPhaseGateDefinition();
	}
	public sealed class BossPhaseGateDefinition
	{
		public bool Enabled { get; set; }

		public float MinimumDurationSeconds { get; set; }

		public float MaximumDurationSeconds { get; set; } = 30f;

		public string RequiredAbilityId { get; set; } = string.Empty;

		public bool ProtectFromDefeat { get; set; }
	}
	internal static class BossDefinitionSnapshot
	{
		private sealed class ConditionReferenceComparer : IEqualityComparer<BossConditionDefinition>
		{
			internal static readonly ConditionReferenceComparer Instance = new ConditionReferenceComparer();

			public bool Equals(BossConditionDefinition? left, BossConditionDefinition? right)
			{
				return left == right;
			}

			public int GetHashCode(BossConditionDefinition value)
			{
				return RuntimeHelpers.GetHashCode(value);
			}
		}

		internal static BossDefinition Clone(BossDefinition source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			return new BossDefinition
			{
				Id = source.Id,
				ContentVersion = source.ContentVersion,
				DisplayName = source.DisplayName,
				Template = source.Template,
				Visual = Clone(source.Visual),
				Stats = Clone(source.Stats),
				Abilities = CloneAbilities(source.Abilities),
				Phases = ClonePhases(source.Phases),
				Rewards = CloneRewards(source.Rewards, 0),
				RewardPolicy = source.RewardPolicy,
				Encounter = Clone(source.Encounter),
				Persistence = Clone(source.Persistence),
				VanillaIntegration = Clone(source.VanillaIntegration),
				ShowBossBar = source.ShowBossBar,
				Live = source.Live,
				FailureMessage = source.FailureMessage
			};
		}

		private static BossPersistenceDefinition Clone(BossPersistenceDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			return new BossPersistenceDefinition
			{
				Mode = source.Mode
			};
		}

		private static BossVanillaIntegrationDefinition Clone(BossVanillaIntegrationDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			return new BossVanillaIntegrationDefinition
			{
				Mode = source.Mode,
				DurationSeconds = source.DurationSeconds
			};
		}

		internal static BossPhaseDefinition Clone(BossPhaseDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			return new BossPhaseDefinition
			{
				Id = source.Id,
				DisplayName = source.DisplayName,
				TriggerHealthFraction = source.TriggerHealthFraction,
				Actions = CloneActions(source.Actions),
				ExitActions = CloneActions(source.ExitActions),
				Abilities = CloneAbilities(source.Abilities),
				Gate = Clone(source.Gate)
			};
		}

		private static BossPhaseGateDefinition Clone(BossPhaseGateDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			return new BossPhaseGateDefinition
			{
				Enabled = source.Enabled,
				MinimumDurationSeconds = source.MinimumDurationSeconds,
				MaximumDurationSeconds = source.MaximumDurationSeconds,
				RequiredAbilityId = source.RequiredAbilityId,
				ProtectFromDefeat = source.ProtectFromDefeat
			};
		}

		private static BossEncounterDefinition Clone(BossEncounterDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			BossCatchTriggerDefinition[] array = ((source.CatchTriggers == null) ? null : new BossCatchTriggerDefinition[source.CatchTriggers.Count]);
			if (source.CatchTriggers != null)
			{
				for (int i = 0; i < source.CatchTriggers.Count; i++)
				{
					BossCatchTriggerDefinition bossCatchTriggerDefinition = source.CatchTriggers[i];
					array[i] = ((bossCatchTriggerDefinition == null) ? null : new BossCatchTriggerDefinition
					{
						Id = bossCatchTriggerDefinition.Id,
						CaughtTemplate = bossCatchTriggerDefinition.CaughtTemplate,
						Probability = bossCatchTriggerDefinition.Probability,
						CooldownSeconds = bossCatchTriggerDefinition.CooldownSeconds,
						MaxActivations = bossCatchTriggerDefinition.MaxActivations,
						RequiredRod = bossCatchTriggerDefinition.RequiredRod,
						RequiredBait = bossCatchTriggerDefinition.RequiredBait,
						ReplaceCatch = bossCatchTriggerDefinition.ReplaceCatch,
						ResetRodAfterReplacement = bossCatchTriggerDefinition.ResetRodAfterReplacement,
						IntroductionGraceSeconds = bossCatchTriggerDefinition.IntroductionGraceSeconds,
						MinimumSpawnDistance = bossCatchTriggerDefinition.MinimumSpawnDistance,
						MaximumSpawnDistance = bossCatchTriggerDefinition.MaximumSpawnDistance,
						RequireWater = bossCatchTriggerDefinition.RequireWater,
						Placement = Clone(bossCatchTriggerDefinition.Placement)
					});
				}
			}
			return new BossEncounterDefinition
			{
				CatchTriggers = array,
				MaximumOwnedMinions = source.MaximumOwnedMinions,
				MaximumOwnedHazards = source.MaximumOwnedHazards,
				MaximumConcurrentAbilities = source.MaximumConcurrentAbilities,
				HookStagger = Clone(source.HookStagger),
				Engagement = Clone(source.Engagement),
				AquaticRecovery = Clone(source.AquaticRecovery)
			};
		}

		private static BossEngagementDefinition Clone(BossEngagementDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			return new BossEngagementDefinition
			{
				Enabled = source.Enabled,
				MaximumTargetDistance = source.MaximumTargetDistance,
				ReengageSpeed = source.ReengageSpeed,
				MaximumSpeed = source.MaximumSpeed,
				PollIntervalSeconds = source.PollIntervalSeconds
			};
		}

		private static BossAquaticRecoveryDefinition Clone(BossAquaticRecoveryDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			return new BossAquaticRecoveryDefinition
			{
				Enabled = source.Enabled,
				MinimumDepth = source.MinimumDepth,
				IgnoreHorizontalProgress = source.IgnoreHorizontalProgress,
				MinimumTargetHeightDifference = source.MinimumTargetHeightDifference,
				StallDurationSeconds = source.StallDurationSeconds,
				MinimumProgressDistance = source.MinimumProgressDistance,
				SurfaceClearance = source.SurfaceClearance,
				MaximumSpeed = source.MaximumSpeed,
				Acceleration = source.Acceleration,
				MaximumDurationSeconds = source.MaximumDurationSeconds,
				RetryCooldownSeconds = source.RetryCooldownSeconds,
				MaximumLateralDistance = source.MaximumLateralDistance,
				ProbeIntervalSeconds = source.ProbeIntervalSeconds
			};
		}

		private static BossVisualDefinition Clone(BossVisualDefinition source)
		{
			//IL_0018: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			if (source == null)
			{
				return null;
			}
			return new BossVisualDefinition
			{
				Prefab = source.Prefab,
				LocalPosition = source.LocalPosition,
				LocalEulerAngles = source.LocalEulerAngles,
				LocalScale = source.LocalScale,
				DisableTemplateRenderers = source.DisableTemplateRenderers,
				RemoveVisualColliders = source.RemoveVisualColliders,
				AssetIdentity = source.AssetIdentity,
				DeclaredAssetDigest = source.DeclaredAssetDigest
			};
		}

		private static BossStatOverrides Clone(BossStatOverrides source)
		{
			if (source == null)
			{
				return null;
			}
			return new BossStatOverrides
			{
				MaxHealth = source.MaxHealth,
				DamageMultiplier = source.DamageMultiplier,
				MovementSpeedMultiplier = source.MovementSpeedMultiplier,
				AttackCooldownMultiplier = source.AttackCooldownMultiplier,
				DashForceMultiplier = source.DashForceMultiplier,
				DashIntervalMultiplier = source.DashIntervalMultiplier,
				KnockbackResistanceMultiplier = source.KnockbackResistanceMultiplier,
				MassMultiplier = source.MassMultiplier,
				ScaleMultiplier = source.ScaleMultiplier,
				VanillaCorpseValueMultiplier = source.VanillaCorpseValueMultiplier
			};
		}

		private static BossPhaseDefinition[] ClonePhases(IReadOnlyList<BossPhaseDefinition> source)
		{
			if (source == null)
			{
				return null;
			}
			BossPhaseDefinition[] array = new BossPhaseDefinition[source.Count];
			for (int i = 0; i < source.Count; i++)
			{
				array[i] = Clone(source[i]);
			}
			return array;
		}

		private static BossActionDefinition[] CloneActions(IReadOnlyList<BossActionDefinition> source)
		{
			if (source == null)
			{
				return null;
			}
			BossActionDefinition[] array = new BossActionDefinition[source.Count];
			for (int i = 0; i < source.Count; i++)
			{
				array[i] = CloneAction(source[i]);
			}
			return array;
		}

		private static BossAbilityDefinition[] CloneAbilities(IReadOnlyList<BossAbilityDefinition> source)
		{
			if (source == null)
			{
				return null;
			}
			BossAbilityDefinition[] array = new BossAbilityDefinition[source.Count];
			for (int i = 0; i < source.Count; i++)
			{
				BossAbilityDefinition bossAbilityDefinition = source[i];
				array[i] = ((bossAbilityDefinition == null) ? null : new BossAbilityDefinition
				{
					Id = bossAbilityDefinition.Id,
					Trigger = bossAbilityDefinition.Trigger,
					InitialDelaySeconds = bossAbilityDefinition.InitialDelaySeconds,
					CooldownSeconds = bossAbilityDefinition.CooldownSeconds,
					MaxRepeats = bossAbilityDefinition.MaxRepeats,
					Probability = bossAbilityDefinition.Probability,
					Condition = CloneCondition(bossAbilityDefinition.Condition),
					ReactiveRearmPolicy = bossAbilityDefinition.ReactiveRearmPolicy,
					Timeline = Clone(bossAbilityDefinition.Timeline),
					TargetSelector = Clone(bossAbilityDefinition.TargetSelector),
					Geometry = CloneGeometry(bossAbilityDefinition.Geometry),
					Telegraph = Clone(bossAbilityDefinition.Telegraph),
					Actions = CloneActions(bossAbilityDefinition.Actions)
				});
			}
			return array;
		}

		private static BossAbilityTimelineDefinition Clone(BossAbilityTimelineDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			return new BossAbilityTimelineDefinition
			{
				TelegraphDurationSeconds = source.TelegraphDurationSeconds,
				ResolveDurationSeconds = source.ResolveDurationSeconds,
				RecoveryDurationSeconds = source.RecoveryDurationSeconds
			};
		}

		private static BossTargetSelectorDefinition Clone(BossTargetSelectorDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			return new BossTargetSelectorDefinition
			{
				Kind = source.Kind,
				MaximumRange = source.MaximumRange,
				LockPositionAtTelegraph = source.LockPositionAtTelegraph,
				LockBeforeResolveSeconds = source.LockBeforeResolveSeconds
			};
		}

		private static BossTelegraphDefinition Clone(BossTelegraphDefinition source)
		{
			//IL_0018: 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)
			if (source == null)
			{
				return null;
			}
			return new BossTelegraphDefinition
			{
				Enabled = source.Enabled,
				Color = source.Color,
				BorderColor = source.BorderColor,
				BorderWidth = source.BorderWidth,
				PulseFrequency = source.PulseFrequency,
				UseColorBlindPattern = source.UseColorBlindPattern,
				AudioClip = source.AudioClip,
				AudioVolume = source.AudioVolume
			};
		}

		private static BossAbilityGeometryDefinition CloneGeometry(BossAbilityGeometryDefinition source)
		{
			//IL_0039: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			if (source == null)
			{
				return null;
			}
			if (!(source is CircleGeometryDefinition circleGeometryDefinition))
			{
				if (!(source is RingGeometryDefinition ringGeometryDefinition))
				{
					if (!(source is LineGeometryDefinition lineGeometryDefinition))
					{
						if (source is ConeGeometryDefinition coneGeometryDefinition)
						{
							return new ConeGeometryDefinition
							{
								LocalOffset = coneGeometryDefinition.LocalOffset,
								Radius = coneGeometryDefinition.Radius,
								AngleDegrees = coneGeometryDefinition.AngleDegrees
							};
						}
						return source;
					}
					return new LineGeometryDefinition
					{
						LocalOffset = lineGeometryDefinition.LocalOffset,
						Length = lineGeometryDefinition.Length,
						Width = lineGeometryDefinition.Width
					};
				}
				return new RingGeometryDefinition
				{
					LocalOffset = ringGeometryDefinition.LocalOffset,
					InnerRadius = ringGeometryDefinition.InnerRadius,
					OuterRadius = ringGeometryDefinition.OuterRadius
				};
			}
			return new CircleGeometryDefinition
			{
				LocalOffset = circleGeometryDefinition.LocalOffset,
				Radius = circleGeometryDefinition.Radius
			};
		}

		private static BossActionDefinition CloneAction(BossActionDefinition source)
		{
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			if (source == null)
			{
				return null;
			}
			if (!(source is StatMultiplierAction statMultiplierAction))
			{
				if (!(source is SpawnMinionsAction spawnMinionsAction))
				{
					if (!(source is ToggleVisualNodeAction toggleVisualNodeAction))
					{
						if (!(source is SetVisualScaleAction setVisualScaleAction))
						{
							if (!(source is PlayAudioAction playAudioAction))
							{
								if (!(source is SpawnVisualEffectAction spawnVisualEffectAction))
								{
									if (!(source is AreaDamageAction areaDamageAction))
									{
										if (!(source is ForceAction forceAction))
										{
											if (source is DashAction dashAction)
											{
												return new DashAction
												{
													Id = dashAction.Id,
													Impulse = dashAction.Impulse,
													VerticalImpulse = dashAction.VerticalImpulse,
													RetainedVelocityFraction = dashAction.RetainedVelocityFraction,
													MaximumSpeed = dashAction.MaximumSpeed,
													MaximumTravelDistance = dashAction.MaximumTravelDistance,
													StoppingDistance = dashAction.StoppingDistance,
													BrakeDurationSeconds = dashAction.BrakeDurationSeconds,
													ExitVelocityFraction = dashAction.ExitVelocityFraction
												};
											}
											return source;
										}
										return new ForceAction
										{
											Id = forceAction.Id,
											Mode = forceAction.Mode,
											Magnitude = forceAction.Magnitude,
											DurationSeconds = forceAction.DurationSeconds,
											VerticalTolerance = forceAction.VerticalTolerance,
											VerticalMultiplier = forceAction.VerticalMultiplier,
											MaximumVelocityChange = forceAction.MaximumVelocityChange
										};
									}
									return new AreaDamageAction
									{
										Id = areaDamageAction.Id,
										Damage = areaDamageAction.Damage,
										DurationSeconds = areaDamageAction.DurationSeconds,
										TickIntervalSeconds = areaDamageAction.TickIntervalSeconds,
										MaxHitsPerTarget = areaDamageAction.MaxHitsPerTarget,
										VerticalTolerance = areaDamageAction.VerticalTolerance
									};
								}
								return new SpawnVisualEffectAction
								{
									Id = spawnVisualEffectAction.Id,
									Prefab = spawnVisualEffectAction.Prefab,
									Anchor = spawnVisualEffectAction.Anchor,
									ParentToBoss = spawnVisualEffectAction.ParentToBoss,
									AlignToAbilityDirection = spawnVisualEffectAction.AlignToAbilityDirection,
									LocalOffset = spawnVisualEffectAction.LocalOffset,
									LocalEulerAngles = spawnVisualEffectAction.LocalEulerAngles,
									LocalScale = spawnVisualEffectAction.LocalScale,
									Lifetime = spawnVisualEffectAction.Lifetime
								};
							}
							return new PlayAudioAction
							{
								Id = playAudioAction.Id,
								Clip = playAudioAction.Clip,
								Volume = playAudioAction.Volume,
								SpatialBlend = playAudioAction.SpatialBlend
							};
						}
						return new SetVisualScaleAction
						{
							Id = setVisualScaleAction.Id,
							ScaleMultiplier = setVisualScaleAction.ScaleMultiplier,
							Persistent = setVisualScaleAction.Persistent
						};
					}
					return new ToggleVisualNodeAction
					{
						Id = toggleVisualNodeAction.Id,
						RelativeTransformPath = toggleVisualNodeAction.RelativeTransformPath,
						Enabled = toggleVisualNodeAction.Enabled,
						Persistent = toggleVisualNodeAction.Persistent
					};
				}
				return new SpawnMinionsAction
				{
					Id = spawnMinionsAction.Id,
					TemplateName = spawnMinionsAction.TemplateName,
					RegisteredBossId = spawnMinionsAction.RegisteredBossId,
					Count = spawnMinionsAction.Count,
					SpawnRadius = spawnMinionsAction.SpawnRadius,
					MaxAliveFromThisAction = spawnMinionsAction.MaxAliveFromThisAction,
					GroupId = spawnMinionsAction.GroupId,
					CleanupPolicy = spawnMinionsAction.CleanupPolicy,
					LifetimeSeconds = spawnMinionsAction.LifetimeSeconds,
					Placement = Clone(spawnMinionsAction.Placement),
					Formation = Clone(spawnMinionsAction.Formation)
				};
			}
			return new StatMultiplierAction
			{
				Id = statMultiplierAction.Id,
				DamageMultiplier = statMultiplierAction.DamageMultiplier,
				MovementSpeedMultiplier = statMultiplierAction.MovementSpeedMultiplier,
				AttackCooldownMultiplier = statMultiplierAction.AttackCooldownMultiplier,
				DashForceMultiplier = statMultiplierAction.DashForceMultiplier,
				DashIntervalMultiplier = statMultiplierAction.DashIntervalMultiplier,
				ModifierId = statMultiplierAction.ModifierId,
				Lifetime = statMultiplierAction.Lifetime,
				DurationSeconds = statMultiplierAction.DurationSeconds
			};
		}

		private static BossPlacementDefinition? Clone(BossPlacementDefinition? source)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (source == null)
			{
				return null;
			}
			return new BossPlacementDefinition
			{
				Mode = source.Mode,
				LocalOffset = source.LocalOffset,
				SearchRadius = source.SearchRadius,
				VerticalSearchDistance = source.VerticalSearchDistance,
				ClearanceRadius = source.ClearanceRadius,
				UseBossBodyClearance = source.UseBossBodyClearance,
				MaximumAttempts = source.MaximumAttempts,
				SocketPath = source.SocketPath,
				FailurePolicy = source.FailurePolicy
			};
		}

		private static BossFormationDefinition? Clone(BossFormationDefinition? source)
		{
			if (source == null)
			{
				return null;
			}
			string[] array;
			if (source.SocketPaths == null)
			{
				array = null;
			}
			else
			{
				array = new string[source.SocketPaths.Count];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = source.SocketPaths[i];
				}
			}
			return new BossFormationDefinition
			{
				Kind = source.Kind,
				Radius = source.Radius,
				Spacing = source.Spacing,
				AngleDegrees = source.AngleDegrees,
				YawOffsetDegrees = source.YawOffsetDegrees,
				FaceCenter = source.FaceCenter,
				SocketPaths = array
			};
		}

		private static BossHookStaggerDefinition Clone(BossHookStaggerDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			return new BossHookStaggerDefinition
			{
				Enabled = source.Enabled,
				MinimumSafeTension = source.MinimumSafeTension,
				MaximumSafeTension = source.MaximumSafeTension,
				ProgressPerSecond = source.ProgressPerSecond,
				DecayPerSecond = source.DecayPerSecond,
				StaggerThreshold = source.StaggerThreshold,
				StaggerDurationSeconds = source.StaggerDurationSeconds,
				RecoveryDurationSeconds = source.RecoveryDurationSeconds,
				MaximumSimultaneousHooks = source.MaximumSimultaneousHooks,
				InterruptActiveAbilityOnStagger = source.InterruptActiveAbilityOnStagger
			};
		}

		private static BossConditionDefinition? CloneCondition(BossConditionDefinition? source)
		{
			if (source == null)
			{
				return null;
			}
			return CloneCondition(source, 0, new HashSet<BossConditionDefinition>(ConditionReferenceComparer.Instance));
		}

		private static BossConditionDefinition CloneCondition(BossConditionDefinition source, int depth, ISet<BossConditionDefinition> recursionStack)
		{
			if (depth > 8 || !recursionStack.Add(source))
			{
				throw new ArgumentException("Condition graph is cyclic or exceeds the supported nesting depth.", "source");
			}
			try
			{
				if (!(source is BossHealthConditionDefinition bossHealthConditionDefinition))
				{
					if (!(source is BossDamageTakenConditionDefinition bossDamageTakenConditionDefinition))
					{
						if (!(source is BossPlayerDistanceConditionDefinition bossPlayerDistanceConditionDefinition))
						{
							if (!(source is BossMinionCountConditionDefinition bossMinionCountConditionDefinition))
							{
								if (!(source is BossMinionDefeatedConditionDefinition bossMinionDefeatedConditionDefinition))
								{
									if (!(source is BossAbilityCompletedConditionDefinition bossAbilityCompletedConditionDefinition))
									{
										if (!(source is BossTimeInPhaseConditionDefinition bossTimeInPhaseConditionDefinition))
										{
											if (!(source is BossHookedConditionDefinition bossHookedConditionDefinition))
											{
												if (!(source is BossAllConditionDefinition bossAllConditionDefinition))
												{
													if (!(source is BossAnyConditionDefinition bossAnyConditionDefinition))
													{
														if (source is BossNotConditionDefinition bossNotConditionDefinition)
														{
															return new BossNotConditionDefinition
															{
																Condition = ((bossNotConditionDefinition.Condition == null) ? null : CloneCondition(bossNotConditionDefinition.Condition, depth + 1, recursionStack))
															};
														}
														return source;
													}
													return new BossAnyConditionDefinition
													{
														Conditions = CloneConditions(bossAnyConditionDefinition.Conditions, depth + 1, recursionStack)
													};
												}
												return new BossAllConditionDefinition
												{
													Conditions = CloneConditions(bossAllConditionDefinition.Conditions, depth + 1, recursionStack)
												};
											}
											return new BossHookedConditionDefinition
											{
												RequiredState = bossHookedConditionDefinition.RequiredState,
												MinimumContinuousSeconds = bossHookedConditionDefinition.MinimumContinuousSeconds
											};
										}
										return new BossTimeInPhaseConditionDefinition
										{
											Comparison = bossTimeInPhaseConditionDefinition.Comparison,
											Seconds = bossTimeInPhaseConditionDefinition.Seconds
										};
									}
									return new BossAbilityCompletedConditionDefinition
									{
										AbilityId = bossAbilityCompletedConditionDefinition.AbilityId,
										Comparison = bossAbilityCompletedConditionDefinition.Comparison,
										Count = bossAbilityCompletedConditionDefinition.Count,
										Scope = bossAbilityCompletedConditionDefinition.Scope,
										WindowSeconds = bossAbilityCompletedConditionDefinition.WindowSeconds
									};
								}
								return new BossMinionDefeatedConditionDefinition
								{
									GroupId = bossMinionDefeatedConditionDefinition.GroupId,
									Comparison = bossMinionDefeatedConditionDefinition.Comparison,
									Count = bossMinionDefeatedConditionDefinition.Count,
									Scope = bossMinionDefeatedConditionDefinition.Scope,
									WindowSeconds = bossMinionDefeatedConditionDefinition.WindowSeconds
								};
							}
							return new BossMinionCountConditionDefinition
							{
								GroupId = bossMinionCountConditionDefinition.GroupId,
								Comparison = bossMinionCountConditionDefinition.Comparison,
								Count = bossMinionCountConditionDefinition.Count
							};
						}
						return new BossPlayerDistanceConditionDefinition
						{
							Comparison = bossPlayerDistanceConditionDefinition.Comparison,
							Distance = bossPlayerDistanceConditionDefinition.Distance,
							RequiredPlayerCount = bossPlayerDistanceConditionDefinition.RequiredPlayerCount
						};
					}
					return new BossDamageTakenConditionDefinition
					{
						Comparison = bossDamageTakenConditionDefinition.Comparison,
						Damage = bossDamageTakenConditionDefinition.Damage,
						Scope = bossDamageTakenConditionDefinition.Scope,
						WindowSeconds = bossDamageTakenConditionDefinition.WindowSeconds
					};
				}
				return new BossHealthConditionDefinition
				{
					Comparison = bossHealthConditionDefinition.Comparison,
					HealthFraction = bossHealthConditionDefinition.HealthFraction
				};
			}
			finally
			{
				recursionStack.Remove(source);
			}
		}

		private static BossConditionDefinition[] CloneConditions(IReadOnlyList<BossConditionDefinition> source, int depth, ISet<BossConditionDefinition> recursionStack)
		{
			if (source == null)
			{
				return null;
			}
			BossConditionDefinition[] array = new BossConditionDefinition[source.Count];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = ((source[i] == null) ? null : CloneCondition(source[i], depth, recursionStack));
			}
			return array;
		}

		private static BossRewardDefinition[] CloneRewards(IReadOnlyList<BossRewardDefinition> source, int depth)
		{
			if (source == null)
			{
				return null;
			}
			BossRewardDefinition[] array = new BossRewardDefinition[source.Count];
			for (int i = 0; i < source.Count; i++)
			{
				array[i] = CloneReward(source[i], depth);
			}
			return array;
		}

		private static BossRewardDefinition CloneReward(BossRewardDefinition source, int depth)
		{
			if (source == null)
			{
				return null;
			}
			if (depth > 8)
			{
				return source;
			}
			if (!(source is VanillaItemReward vanillaItemReward))
			{
				if (!(source is MoneyReward moneyReward))
				{
					if (!(source is MultipleReward multipleReward))
					{
						if (!(source is WeightedReward weightedReward))
						{
							if (source is CustomItemReward customItemReward)
							{
								return new CustomItemReward
								{
									ProviderId = customItemReward.ProviderId,
									ItemId = customItemReward.ItemId,
									Count = customItemReward.Count
								};
							}
							return source;
						}
						WeightedRewardEntry[] array = ((weightedReward.Entries == null) ? null : new WeightedRewardEntry[weightedReward.Entries.Count]);
						if (weightedReward.Entries != null)
						{
							for (int i = 0; i < weightedReward.Entries.Count; i++)
							{
								WeightedRewardEntry weightedRewardEntry = weightedReward.Entries[i];
								array[i] = ((weightedRewardEntry == null) ? null : new WeightedRewardEntry
								{
									Weight = weightedRewardEntry.Weight,
									Reward = ((weightedRewardEntry.Reward == null) ? null : CloneReward(weightedRewardEntry.Reward, depth + 1))
								});
							}
						}
						return new WeightedReward
						{
							Rolls = weightedReward.Rolls,
							Entries = array
						};
					}
					return new MultipleReward
					{
						Rewards = CloneRewards(multipleReward.Rewards, depth + 1)
					};
				}
				return new MoneyReward
				{
					Amount = moneyReward.Amount
				};
			}
			return new VanillaItemReward
			{
				ItemName = vanillaItemReward.ItemName,
				Count = vanillaItemReward.Count,
				SpawnRadius = vanillaItemReward.SpawnRadius
			};
		}
	}
	public static class BossDefinitionValidator
	{
		private sealed class ConditionReferenceComparer : IEqualityComparer<BossConditionDefinition>
		{
			internal static readonly ConditionReferenceComparer Instance = new ConditionReferenceComparer();

			public bool Equals(BossConditionDefinition? left, BossConditionDefinition? right)
			{
				return left == right;
			}

			public int GetHashCode(BossConditionDefinition value)
			{
				return RuntimeHelpers.GetHashCode(value);
			}
		}

		public const int MaximumPhases = 32;

		public const int MaximumActionsPerPhase = 32;

		public const int MaximumAbilitiesPerPhase = 32;

		public const int MaximumAbilitiesPerDefinition = 128;

		public const int MaximumActionsPerAbility = 32;

		public const int MaximumAbilityRepeats = 1024;

		public const int MaximumCatchTriggers = 32;

		public const float MaximumCatchIntroductionGraceSeconds = 30f;

		public const int MaximumCatchActivations = 100000;

		public const int MaximumMinionsPerAction = 32;

		public const int MaximumConditionNodesPerAbility = 32;

		public const int MaximumConditionNodesPerDefinition = 256;

		public const int MaximumConditionNestingDepth = 8;

		public const int MaximumConditionChildren = 16;

		public const int MaximumConditionCounter = 1000000;

		public const int MaximumConditionPlayerCount = 64;

		public const int MaximumFormationSockets = 32;

		public const int MaximumPlacementAttempts = 32;

		public const int MaximumSimultaneousHooks = 8;

		public const int MaximumActiveModifiers = 64;

		public const int MaximumActionResultCount = 1024;

		public const int MaximumValidationIssues = 512;

		public const int MaximumDeclaredActiveMinions = 128;

		public const int MaximumTopLevelRewards = 64;

		public const int MaximumRewardChildren = 64;

		public const int MaximumRewardRolls = 64;

		public const int MaximumRewardNodes = 256;

		public const int MaximumRewardItems = 256;

		public const int MaximumRewardNestingDepth = 8;

		public const int MaximumHealth = 10000000;

		public const float MinimumMultiplier = 0.01f;

		public const float MaximumMultiplier = 100f;

		public const float MaximumSpawnRadius = 1000f;

		public const float MaximumAudioVolume = 4f;

		public const float MaximumVisualEffectLifetime = 300f;

		public const float MaximumVisualOffset = 100000f;

		public const float MaximumVisualScale = 1000f;

		public const float MaximumAbilityDuration = 3600f;

		public const float MaximumAbilityCooldown = 86400f;

		public const float MinimumVanillaBossDuration = 1f;

		public const float MaximumVanillaBossDuration = 86400f;

		public const float MaximumAbilityRange = 10000f;

		public const float MaximumGeometryExtent = 1000f;

		public const float MaximumForceMagnitude = 1000f;

		public const float MaximumVelocityChange = 1000f;

		public const float MaximumDashBrakeDuration = 10f;

		public const float MaximumEngagementPollInterval = 10f;

		public const float MinimumAquaticRecoveryDepth = 0.5f;

		public const float MaximumAquaticRecoveryDepth = 50f;

		public const float MinimumAquaticRecoveryTargetHeightDifference = 0.25f;

		public const float MaximumAquaticRecoveryTargetHeightDifference = 50f;

		public const float MinimumAquaticRecoveryStallDuration = 0.25f;

		public const float MaximumAquaticRecoveryStallDuration = 30f;

		public const float MinimumAquaticRecoveryProgressDistance = 0.05f;

		public const float MaximumAquaticRecoveryProgressDistance = 10f;

		public const float MinimumAquaticRecoverySurfaceClearance = 0.25f;

		public const float MaximumAquaticRecoverySurfaceClearance = 10f;

		public const float MinimumAquaticRecoverySpeed = 0.5f;

		public const float MaximumAquaticRecoverySpeed = 12f;

		public const float MinimumAquaticRecoveryAcceleration = 0.5f;

		public const float MaximumAquaticRecoveryAcceleration = 30f;

		public const float MinimumAquaticRecoveryDuration = 0.25f;

		public const float MaximumAquaticRecoveryDuration = 30f;

		public const float MinimumAquaticRecoveryRetryCooldown = 0.5f;

		public const float MaximumAquaticRecoveryRetryCooldown = 120f;

		public const float MinimumAquaticRecoveryLateralDistance = 0.5f;

		public const float MaximumAquaticRecoveryLateralDistance = 30f;

		public const float MinimumAquaticRecoveryProbeInterval = 0.1f;

		public const float MaximumAquaticRecoveryProbeInterval = 1f;

		public const float MaximumHookRate = 100f;

		public const int MaximumAreaDamage = 10000000;

		public const int MaximumHitsPerTarget = 1024;

		public const int MaximumOwnedMinionBudget = 256;

		public const int MaximumOwnedHazardBudget = 256;

		public const int MaximumConcurrentAbilityBudget = 1;

		public const int MaximumEncounterExecutionClaims = 4096;

		public const int MaximumDisplayNameLength = 256;

		public const int MaximumTemplateNameLength = 256;

		public const int MaximumPhaseIdLength = 128;

		public const int MaximumAssetIdentityLength = 1024;

		public const int MaximumRelativePathLength = 1024;

		public const int MaximumRewardIdentifierLength = 256;

		public const int MaximumAbilityIdLength = 128;

		public const int MaximumCatchTriggerIdLength = 128;

		public const int MaximumCatchFilterLength = 256;

		public const int MaximumMinionGroupIdLength = 128;

		public const int MaximumActionIdLength = 128;

		public const int MaximumModifierIdLength = 128;

		public const int MaximumResultMessageLength = 1024;

		private static readonly Regex NamespacedId = new Regex("^[a-z0-9][a-z0-9_-]*(?:\\.[a-z0-9][a-z0-9_-]*)+$", RegexOptions.CultureInvariant);

		private static readonly Regex SemanticVersion = new Regex("^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$", RegexOptions.CultureInvariant);

		public static bool IsValidBossId(string? id)
		{
			if (!string.IsNullOrEmpty(id) && id.Length <= 128)
			{
				return NamespacedId.IsMatch(id);
			}
			return false;
		}

		public static BossValidationReport Analyze(BossDefinition definition)
		{
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			IReadOnlyList<string> readOnlyList = ValidateLegacyMessages(definition);
			List<BossValidationIssue> list = new List<BossValidationIssue>();
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				if (list.Count >= 512)
				{
					break;
				}
				AddIssue(list, "legacy.definition_invalid", "$", readOnlyList[i]);
			}
			ValidateVersion4(definition, list);
			if (list.Count == 0)
			{
				try
				{
					if (!BossManifestBuilder.TryValidateDefinitionWireBudget(definition, out string error))
					{
						AddIssue(list, "manifest.wire_budget_exceeded", "$", error);
					}
				}
				catch (Exception ex)
				{
					AddIssue(list, "manifest.encoding_failed", "$", "Definition could not be encoded safely: " + ex.GetType().Name + ": " + ex.Message);
				}
			}
			TrimIssueBudget(list);
			return new BossValidationReport(list);
		}

		public static IReadOnlyList<string> Validate(BossDefinition definition)
		{
			return Analyze(definition).Errors.Select((BossValidationIssue issue) => issue.Message).ToArray();
		}

		private static IReadOnlyList<string> ValidateLegacyMessages(BossDefinition definition)
		{
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: 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_0235: Unknown result type (might be due to invalid IL or missing references)
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			List<string> list = new List<string>();
			if (!IsValidBossId(definition.Id))
			{
				list.Add("Id must be a lowercase namespaced identifier using letters, digits, '.', '-' or '_'.");
			}
			if (string.IsNullOrWhiteSpace(definition.ContentVersion) || definition.ContentVersion.Length > 128 || !SemanticVersion.IsMatch(definition.ContentVersion))
			{
				list.Add("ContentVersion must be a semantic version such as 1.0.0 or 1.0.0-beta.1.");
			}
			if (string.IsNullOrWhiteSpace(definition.DisplayName) || definition.DisplayName.Length > 256)
			{
				list.Add($"DisplayName is required and cannot exceed {256} characters.");
			}
			if (string.IsNullOrWhiteSpace(definition.Template) || definition.Template.Length > 256)
			{
				list.Add($"Template is required and cannot exceed {256} characters.");
			}
			if (definition.Visual == null)
			{
				list.Add("Visual cannot be null.");
			}
			if (definition.Stats == null)
			{
				list.Add("Stats cannot be null.");
			}
			if (definition.Persistence == null)
			{
				list.Add("Persistence cannot be null.");
			}
			else if (!Enum.IsDefined(typeof(BossPersistenceMode), definition.Persistence.Mode))
			{
				list.Add("Persistence Mode is not a supported value.");
			}
			if (definition.Visual != null)
			{
				if (definition.Visual.AssetIdentity != null && definition.Visual.AssetIdentity.Length > 1024)
				{
					list.Add($"Visual AssetIdentity cannot exceed {1024} characters.");
				}
				if (!string.IsNullOrEmpty(definition.Visual.DeclaredAssetDigest) && !BossManifestDigest.TryNormalizeSha256(definition.Visual.DeclaredAssetDigest, out string _))
				{
					list.Add("Visual DeclaredAssetDigest must be a 64-character SHA-256 hexadecimal digest, optionally prefixed with 'sha256:'.");
				}
				if (!IsFinite(definition.Visual.LocalPosition) || !IsFinite(definition.Visual.LocalEulerAngles) || !IsFinite(definition.Visual.LocalScale))
				{
					list.Add("Visual position, rotation and scale must contain only finite values.");
				}
				else
				{
					if (!IsWithinMagnitude(definition.Visual.LocalPosition, 100000f))
					{
						list.Add($"Visual local position components cannot exceed {100000f} in magnitude.");
					}
					if (!IsWithinMagnitude(definition.Visual.LocalScale, 1000f))
					{
						list.Add($"Visual local scale components cannot exceed {1000f} in magnitude.");
					}
				}
			}
			ValidateStats(definition.Stats, list);
			if (!Enum.IsDefined(typeof(RewardPolicy), definition.RewardPolicy))
			{
				list.Add("RewardPolicy is not a supported value.");
			}
			ValidateVanillaIntegration(definition.VanillaIntegration, list);
			ValidateEncounter(definition.Encounter, list);
			HashSet<string> abilityIds = new HashSet<string>(StringComparer.Ordinal);
			long declaredActiveMinions = 0L;
			long declaredExecutionClaims = 1L;
			long num = 0L;
			if (definition.Abilities == null)
			{
				list.Add("Abilities cannot be null; use an empty collection.");
			}
			else if (definition.Abilities.Count > 32)
			{
				list.Add($"A boss may declare at most {32} global abilities.");
			}
			IReadOnlyList<BossAbilityDefinition> readOnlyList = definition.Abilities ?? Array.Empty<BossAbilityDefinition>();
			num += readOnlyList.Count;
			for (int i = 0; i < Math.Min(readOnlyList.Count, 32); i++)
			{
				ValidateAbility(readOnlyList[i], "global", abilityIds, list, ref declaredActiveMinions, ref declaredExecutionClaims, isGlobal: true);
			}
			HashSet<float> hashSet = new HashSet<float>();
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			if (definition.Phases == null)
			{
				list.Add("Phases cannot be null; use an empty collection.");
			}
			else if (definition.Phases.Count > 32)
			{
				list.Add($"A boss may declare at most {32} phases.");
			}
			IReadOnlyList<BossPhaseDefinition> readOnlyList2 = definition.Phases ?? Array.Empty<BossPhaseDefinition>();
			for (int j = 0; j < Math.Min(readOnlyList2.Count, 32); j++)
			{
				BossPhaseDefinition phase = readOnlyList2[j];
				if (phase == null)
				{
					list.Add("Phases cannot contain null entries.");
					continue;
				}
				if (!EncounterContractValidation.IsSafeToken(phase.Id, 128))
				{
					list.Add($"Every phase requires a normalized, control-free Id no longer than {128} characters.");
				}
				else if (!hashSet2.Add(phase.Id))
				{
					list.Add("Duplicate phase Id '" + phase.Id + "'.");
				}
				if (!IsFinite(phase.TriggerHealthFraction) || phase.TriggerHealthFraction < 0f || phase.TriggerHealthFraction > 1f)
				{
					list.Add("Phase '" + phase.Id + "' threshold must be between 0 and 1.");
				}
				else if (!hashSet.Add(phase.TriggerHealthFraction))
				{
					list.Add($"Duplicate phase threshold {phase.TriggerHealthFraction}.");
				}
				if (phase.Actions == null)
				{
					list.Add("Phase '" + phase.Id + "' Actions cannot be null; use an empty collection.");
				}
				else if (phase.Actions.Count > 32)
				{
					list.Add($"Phase '{phase.Id}' may declare at most {32} actions.");
				}
				IReadOnlyList<BossActionDefinition> readOnlyList3 = phase.Actions ?? Array.Empty<BossActionDefinition>();
				int num2 = Math.Min(readOnlyList3.Count, 32);
				declaredExecutionClaims += num2;
				for (int k = 0; k < num2; k++)
				{
					ValidateAction(readOnlyList3[k], phase.Id, list, ref declaredActiveMinions, isAbilityAction: false);
				}
				IReadOnlyList<BossActionDefinition> readOnlyList4 = phase.ExitActions ?? Array.Empty<BossActionDefinition>();
				int num3 = Math.Min(readOnlyList4.Count, 32);
				declaredExecutionClaims += num3;
				for (int l = 0; l < num3; l++)
				{
					if (readOnlyList4[l] is SpawnMinionsAction { MaxAliveFromThisAction: >0 } spawnMinionsAction)
					{
						declaredActiveMinions = SaturatingAdd(declaredActiveMinions, spawnMinionsAction.MaxAliveFromThisAction);
					}
				}
				if (phase.Abilities == null)
				{
					list.Add("Phase '" + phase.Id + "' Abilities cannot be null; use an empty collection.");
				}
				else if (phase.Abilities.Count > 32)
				{
					list.Add($"Phase '{phase.Id}' may declare at most {32} abilities.");
				}
				IReadOnlyList<BossAbilityDefinition> readOnlyList5 = phase.Abilities ?? Array.Empty<BossAbilityDefinition>();
				num += readOnlyList5.Count;
				for (int m = 0; m < Math.Min(readOnlyList5.Count, 32); m++)
				{
					ValidateAbility(readOnlyList5[m], phase.Id, abilityIds, list, ref declaredActiveMinions, ref declaredExecutionClaims, isGlobal: false);
				}
				ValidatePhaseGate(phase, readOnlyList5, !readOnlyList2.Any((BossPhaseDefinition candidate) => candidate != null && IsFinite(candidate.TriggerHealthFraction) && candidate.TriggerHealthFraction < phase.TriggerHealthFraction), list);
			}
			if (num > 128)
			{
				list.Add($"A boss may declare at most {128} abilities across its global and phase collections.");
			}
			if (declaredActiveMinions > 128)
			{
				list.Add($"A boss may declare at most {128} simultaneously active minions across all phase actions.");
			}
			if (definition.Encounter != null && definition.Encounter.MaximumOwnedMinions >= 0 && declaredActiveMinions > definition.Encounter.MaximumOwnedMinions)
			{
				list.Add($"Declared active minions ({declaredActiveMinions}) exceed the encounter MaximumOwnedMinions budget ({definition.Encounter.MaximumOwnedMinions}).");
			}
			if (definition.Rewards == null)
			{
				list.Add("Rewards cannot be null; use an empty collection.");
			}
			else if (definition.Rewards.Count > 64)
			{
				list.Add($"A boss may declare at most {64} top-level rewards.");
			}
			IReadOnlyList<BossRewardDefinition> readOnlyList6 = definition.Rewards ?? Array.Empty<BossRewardDefinition>();
			declaredExecutionClaims += Math.Min(readOnlyList6.Count, 64);
			if (definition.RewardPolicy == RewardPolicy.PreserveVanilla && readOnlyList6.Count != 0)
			{
				list.Add("RewardPolicy PreserveVanilla requires Rewards to be empty so configured rewards are not silently ignored.");
			}
			int nodes = 0;
			long num4 = 0L;
			for (int num5 = 0; num5 < Math.Min(readOnlyList6.Count, 64); num5++)
			{
				num4 = SaturatingAdd(num4, ValidateReward(readOnlyList6[num5], list, 0, ref nodes));
			}
			if (nodes > 256)
			{
				list.Add($"A boss reward graph may contain at most {256} nodes.");
			}
			if (num4 > 256)
			{
				list.Add($"A boss may spawn at most {256} reward items in the worst case.");
			}
			if (declaredExecutionClaims > 4096)
			{
				list.Add($"A boss may require at most {4096} exactly-once execution claims across ability actions, rewards and cleanup; " + $"this definition can require {declaredExecutionClaims} in the worst case.");
			}
			return list;
		}

		internal static IReadOnlyList<BossPhaseDefinition> OrderPhases(IEnumerable<BossPhaseDefinition>? phases)
		{
			return (phases ?? Array.Empty<BossPhaseDefinition>()).OrderByDescending((BossPhaseDefinition x) => x.TriggerHealthFraction).ThenBy<BossPhaseDefinition, string>((BossPhaseDefinition x) => x.Id, StringComparer.Ordinal).ToArray();
		}

		private static void ValidateStats(BossStatOverrides? stats, ICollection<string> errors)
		{
			if (stats != null)
			{
				if (stats.MaxHealth.HasValue && (stats.MaxHealth <= 0 || stats.MaxHealth > 10000000))
				{
					errors.Add($"MaxHealth must be between 1 and {10000000}.");
				}
				ValidateMultiplier(stats.DamageMultiplier, "DamageMultiplier", errors);
				ValidateMultiplier(stats.MovementSpeedMultiplier, "MovementSpeedMultiplier", errors);
				ValidateMultiplier(stats.AttackCooldownMultiplier, "AttackCooldownMultiplier", errors);
				ValidateMultiplier(stats.DashForceMultiplier, "DashForceMultiplier", errors);
				ValidateMultiplier(stats.DashIntervalMultiplier, "DashIntervalMultiplier", errors);
				ValidateMultiplier(stats.KnockbackResistanceMultiplier, "KnockbackResistanceMultiplier", errors);
				ValidateMultiplier(stats.MassMultiplier, "MassMultiplier", errors);
				ValidateMultiplier(stats.ScaleMultiplier, "ScaleMultiplier", errors);
				ValidateMultiplier(stats.VanillaCorpseValueMultiplier, "VanillaCorpseValueMultiplier", errors);
			}
		}

		private static void ValidateVanillaIntegration(BossVanillaIntegrationDefinition? integration, ICollection<string> errors)
		{
			if (integration == null)
			{
				errors.Add("VanillaIntegration cannot be null.");
			}
			else if (!Enum.IsDefined(typeof(BossVanillaMode), integration.Mode))
			{
				errors.Add("VanillaIntegration Mode is not a supported value.");
			}
			else if (integration.Mode == BossVanillaMode.TemplateDefault)
			{
				if (integration.DurationSeconds.HasValue)
				{
					errors.Add("VanillaIntegration DurationSeconds must be null when Mode is TemplateDefault.");
				}
			}
			else if (!integration.DurationSeconds.HasValue)
			{
				errors.Add("VanillaIntegration DurationSeconds is required for VanillaMiniBoss and VanillaBoss modes.");
			}
			else if (!IsFinite(integration.DurationSeconds.Value) || integration.DurationSeconds.Value < 1f || integration.DurationSeconds.Value > 86400f)
			{
				errors.Add($"VanillaIntegration DurationSeconds must be a finite value between {1f} and {86400f}.");
			}
		}

		private static void ValidateEncounter(BossEncounterDefinition? encounter, ICollection<string> errors)
		{
			if (encounter == null)
			{
				errors.Add("Encounter cannot be null.");
				return;
			}
			if (encounter.MaximumOwnedMinions < 0 || encounter.MaximumOwnedMinions > 256)
			{
				errors.Add($"Encounter MaximumOwnedMinions must be between 0 and {256}.");
			}
			if (encounter.MaximumOwnedHazards < 0 || encounter.MaximumOwnedHazards > 256)
			{
				errors.Add($"Encounter MaximumOwnedHazards must be between 0 and {256}.");
			}
			if (encounter.MaximumConcurrentAbilities != 1)
			{
				errors.Add("Encounter MaximumConcurrentAbilities must be 1 because snapshots expose one active ability.");
			}
			ValidateEngagement(encounter.Engagement, errors);
			ValidateAquaticRecovery(encounter.AquaticRecovery, errors);
			if (encounter.CatchTriggers == null)
			{
				errors.Add("Encounter CatchTriggers cannot be null; use an empty collection.");
				return;
			}
			if (encounter.CatchTriggers.Count > 32)
			{
				errors.Add($"An encounter may declare at most {32} catch triggers.");
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < Math.Min(encounter.CatchTriggers.Count, 32); i++)
			{
				BossCatchTriggerDefinition bossCatchTriggerDefinition = encounter.CatchTriggers[i];
				if (bossCatchTriggerDefinition == null)
				{
					errors.Add("Encounter CatchTriggers cannot contain null entries.");
					continue;
				}
				if (!EncounterContractValidation.IsSafeToken(bossCatchTriggerDefinition.Id, 128))
				{
					errors.Add($"Every catch trigger requires a normalized, control-free Id no longer than {128} characters.");
				}
				else if (!hashSet.Add(bossCatchTriggerDefinition.Id))
				{
					errors.Add("Duplicate catch trigger Id '" + bossCatchTriggerDefinition.Id + "'.");
				}
				if (string.IsNullOrWhiteSpace(bossCatchTriggerDefinition.CaughtTemplate) || bossCatchTriggerDefinition.CaughtTemplate.Length > 256)
				{
					errors.Add($"Catch trigger '{bossCatchTriggerDefinition.Id}' requires a caught template no longer than {256} characters.");
				}
				if (!IsFinite(bossCatchTriggerDefinition.Probability) || bossCatchTriggerDefinition.Probability < 0f || bossCatchTriggerDefinition.Probability > 1f)
				{
					errors.Add("Catch trigger '" + bossCatchTriggerDefinition.Id + "' Probability must be between 0 and 1.");
				}
				if (!IsFinite(bossCatchTriggerDefinition.CooldownSeconds) || bossCatchTriggerDefinition.CooldownSeconds < 0f || bossCatchTriggerDefinition.CooldownSeconds > 86400f)
				{
					errors.Add($"Catch trigger '{bossCatchTriggerDefinition.Id}' CooldownSeconds must be between 0 and {86400f}.");
				}
				if (bossCatchTriggerDefinition.MaxActivations < 0 || bossCatchTriggerDefinition.MaxActivations > 100000)
				{
					errors.Add($"Catch trigger '{bossCatchTriggerDefinition.Id}' MaxActivations must be between 0 and {100000}.");
				}
				ValidateOptionalFilter(bossCatchTriggerDefinition.RequiredRod, "RequiredRod", bossCatchTriggerDefinition.Id, errors);
				ValidateOptionalFilter(bossCatchTriggerDefinition.RequiredBait, "RequiredBait", bossCatchTriggerDefinition.Id, errors);
				if (bossCatchTriggerDefinition.ResetRodAfterReplacement && !bossCatchTriggerDefinition.ReplaceCatch)
				{
					errors.Add("Catch trigger '" + bossCatchTriggerDefinition.Id + "' ResetRodAfterReplacement requires ReplaceCatch.");
				}
				BossPlacementDefinition? placement = bossCatchTriggerDefinition.Placement;
				if (placement != null && placement.UseBossBodyClearance && (!bossCatchTriggerDefinition.ReplaceCatch || !bossCatchTriggerDefinition.RequireWater))
				{
					errors.Add("Catch trigger '" + bossCatchTriggerDefinition.Id + "' body-clearance placement requires ReplaceCatch and RequireWater.");
				}
				if (!IsFinite(bossCatchTriggerDefinition.IntroductionGraceSeconds) || bossCatchTriggerDefinition.IntroductionGraceSeconds < 0f || bossCatchTriggerDefinition.IntroductionGraceSeconds > 30f)
				{
					errors.Add("Catch trigger '" + bossCatchTriggerDefinition.Id + "' IntroductionGraceSeconds must be between 0 and " + $"{30f}.");
				}
				if (!IsFinite(bossCatchTriggerDefinition.MinimumSpawnDistance) || !IsFinite(bossCatchTriggerDefinition.MaximumSpawnDistance) || bossCatchTriggerDefinition.MinimumSpawnDistance < 0f || bossCatchTriggerDefinition.MaximumSpawnDistance < bossCatchTriggerDefinition.MinimumSpawnDistance || bossCatchTriggerDefinition.MaximumSpawnDistance > 1000f)
				{
					errors.Add($"Catch trigger '{bossCatchTriggerDefinition.Id}' spawn distances must be finite, ordered, non-negative and at most {1000f}.");
				}
			}
		}

		private static void ValidateEngagement(BossEngagementDefinition? engagement, ICollection<string> errors)
		{
			if (engagement == null)
			{
				errors.Add("Encounter Engagement cannot be null.");
				return;
			}
			if (!IsFinite(engagement.MaximumTargetDistance) || engagement.MaximumTargetDistance <= 0f || engagement.MaximumTargetDistance > 10000f)
			{
				errors.Add($"Engagement MaximumTargetDistance must be greater than zero and at most {10000f}.");
			}
			if (!IsFinite(engagement.ReengageSpeed) || engagement.ReengageSpeed <= 0f || engagement.ReengageSpeed > 1000f)
			{
				errors.Add($"Engagement ReengageSpeed must be greater than zero and at most {1000f}.");
			}
			if (!IsFinite(engagement.MaximumSpeed) || engagement.MaximumSpeed <= 0f || engagement.MaximumSpeed > 1000f)
			{
				errors.Add($"Engagement MaximumSpeed must be greater than zero and at most {1000f}.");
			}
			else if (IsFinite(engagement.ReengageSpeed) && engagement.ReengageSpeed > engagement.MaximumSpeed)
			{
				errors.Add("Engagement ReengageSpeed cannot exceed MaximumSpeed.");
			}
			if (!IsFinite(engagement.PollIntervalSeconds) || engagement.PollIntervalSeconds <= 0f || engagement.PollIntervalSeconds > 10f)
			{
				errors.Add($"Engagement PollIntervalSeconds must be greater than zero and at most {10f}.");
			}
		}

		private static void ValidateAquaticRecovery(BossAquaticRecoveryDefinition? recovery, ICollection<string> errors)
		{
			if (recovery == null)
			{
				errors.Add("Encounter AquaticRecovery cannot be null.");
				return;
			}
			ValidateAquaticRecoveryRange(recovery.MinimumDepth, 0.5f, 50f, "MinimumDepth", errors);
			ValidateAquaticRecoveryRange(recovery.MinimumTargetHeightDifference, 0.25f, 50f, "MinimumTargetHeightDifference", errors);
			ValidateAquaticRecoveryRange(recovery.StallDurationSeconds, 0.25f, 30f, "StallDurationSeconds", errors);
			ValidateAquaticRecoveryRange(recovery.MinimumProgressDistance, 0.05f, 10f, "MinimumProgressDistance", errors);
			ValidateAquaticRecoveryRange(recovery.SurfaceClearance, 0.25f, 10f, "SurfaceClearance", errors);
			ValidateAquaticRecoveryRange(recovery.MaximumSpeed, 0.5f, 12f, "MaximumSpeed", errors);
			ValidateAquaticRecoveryRange(recovery.Acceleration, 0.5f, 30f, "Acceleration", errors);
			ValidateAquaticRecoveryRange(recovery.MaximumDurationSeconds, 0.25f, 30f, "MaximumDurationSeconds", errors);
			ValidateAquaticRecoveryRange(recovery.RetryCooldownSeconds, 0.5f, 120f, "RetryCooldownSeconds", errors);
			ValidateAquaticRecoveryRange(recovery.MaximumLateralDistance, 0.5f, 30f, "MaximumLateralDistance", errors);
			ValidateAquaticRecoveryRange(recovery.ProbeIntervalSeconds, 0.1f, 1f, "ProbeIntervalSeconds", errors);
			if (IsFinite(recovery.MinimumDepth) && IsFinite(recovery.SurfaceClearance) && recovery.MinimumDepth <= recovery.SurfaceClearance)
			{
				errors.Add("AquaticRecovery MinimumDepth must be greater than SurfaceClearance.");
			}
			if (IsFinite(recovery.StallDurationSeconds) && IsFinite(recovery.ProbeIntervalSeconds) && recovery.StallDurationSeconds < recovery.ProbeIntervalSeconds)
			{
				errors.Add("AquaticRecovery StallDurationSeconds must be at least ProbeIntervalSeconds.");
			}
			if (IsFinite(recovery.MaximumDurationSeconds) && IsFinite(recovery.ProbeIntervalSeconds) && recovery.MaximumDurationSeconds < recovery.ProbeIntervalSeconds)
			{
				errors.Add("AquaticRecovery MaximumDurationSeconds must be at least ProbeIntervalSeconds.");
			}
		}

		private static void ValidateAquaticRecoveryRange(float value, float minimum, float maximum, string property, ICollection<string> errors)
		{
			if (!IsFinite(value) || value < minimum || value > maximum)
			{
				errors.Add($"AquaticRecovery {property} must be finite and between {minimum} and {maximum}.");
			}
		}

		private static void ValidatePhaseGate(BossPhaseDefinition phase, IReadOnlyList<BossAbilityDefinition> abilities, bool isFinalPhase, ICollection<string> errors)
		{
			BossPhaseGateDefinition gate = phase.Gate;
			if (gate == null)
			{
				errors.Add("Phase '" + phase.Id + "' Gate cannot be null.");
				return;
			}
			if (!IsDuration(gate.MinimumDurationSeconds))
			{
				errors.Add($"Phase '{phase.Id}' gate MinimumDurationSeconds must be between 0 and {3600f}.");
			}
			if (!IsFinite(gate.MaximumDurationSeconds) || gate.MaximumDurationSeconds <= 0f || gate.MaximumDurationSeconds > 3600f || gate.MaximumDurationSeconds < gate.MinimumDurationSeconds)
			{
				errors.Add($"Phase '{phase.Id}' gate MaximumDurationSeconds must be positive, no greater than {3600f}, and not shorter than its minimum.");
			}
			if (!string.IsNullOrEmpty(gate.RequiredAbilityId))
			{
				if (!EncounterContractValidation.IsSafeToken(gate.RequiredAbilityId, 128))
				{
					errors.Add("Phase '" + phase.Id + "' gate RequiredAbilityId must be a normalized, control-free ability ID.");
				}
				else if (!abilities.Any((BossAbilityDefinition ability) => ability != null && string.Equals(ability.Id, gate.RequiredAbilityId, StringComparison.Ordinal)))
				{
					errors.Add("Phase '" + phase.Id + "' gate RequiredAbilityId must reference an ability owned by that phase.");
				}
			}
			if (gate.ProtectFromDefeat && !gate.Enabled)
			{
				errors.Add("Phase '" + phase.Id + "' gate ProtectFromDefeat requires Enabled=true.");
			}
			if (gate.ProtectFromDefeat && !isFinalPhase)
			{
				errors.Add("Phase '" + phase.Id + "' gate ProtectFromDefeat may only be used on the final phase.");
			}
			if (gate.Enabled && phase.TriggerHealthFraction <= 0f)
			{
				errors.Add("Phase '" + phase.Id + "' must have a positive health threshold when its progression gate is enabled.");
			}
		}

		private static void ValidateOptionalFilter(string? value, string name, string triggerId, ICollection<string> errors)
		{
			if (value != null && !EncounterContractValidation.IsSafeToken(value, 256))
			{
				errors.Add($"Catch trigger '{triggerId}' {name} must be null or a normalized, control-free value no longer than {256} characters.");
			}
		}

		private static void ValidateHookStagger(BossHookStaggerDefinition? value, string path, ICollection<BossValidationIssue> issues)
		{
			if (value == null)
			{
				AddIssue(issues, "hook.missing_definition", path, "Encounter HookStagger cannot be null.");
				return;
			}
			if (!IsFinite(value.MinimumSafeTension) || !IsFinite(value.MaximumSafeTension) || value.MinimumSafeTension < 0f || value.MaximumSafeTension > 1f || value.MaximumSafeTension < value.MinimumSafeTension)
			{
				AddIssue(issues, "hook.invalid_tension_bounds", path, "HookStagger safe tension bounds must be finite, ordered and between 0 and 1.");
			}
			if (!IsFinite(value.ProgressPerSecond) || value.ProgressPerSecond < 0f || value.ProgressPerSecond > 100f || !IsFinite(value.DecayPerSecond) || value.DecayPerSecond < 0f || value.DecayPerSecond > 100f)
			{
				AddIssue(issues, "hook.invalid_rate", path, $"HookStagger progress and decay rates must be finite values between 0 and {100f}.");
			}
			if (!IsFinite(value.StaggerThreshold) || value.StaggerThreshold <= 0f || value.StaggerThreshold > 1f)
			{
				AddIssue(issues, "hook.invalid_threshold", path + ".staggerThreshold", "HookStagger StaggerThreshold must be between 0 (exclusive) and 1.");
			}
			if (!IsDuration(value.StaggerDurationSeconds) || !IsDuration(value.RecoveryDurationSeconds))
			{
				AddIssue(issues, "hook.invalid_duration", path, $"HookStagger durations must be finite values between 0 and {3600f}.");
			}
			if (value.MaximumSimultaneousHooks <= 0 || value.MaximumSimultaneousHooks > 8)
			{
				AddIssue(issues, "hook.invalid_limit", path + ".maximumSimultaneousHooks", $"HookStagger MaximumSimultaneousHooks must be between 1 and {8}.");
			}
		}

		private static void ValidatePlacement(BossPlacementDefinition? value, string path, ICollection<BossValidationIssue> issues, bool allowBossRelative, bool allowBossBodyClearance = false)
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			if (value == null)
			{
				return;
			}
			if (value.UseBossBodyClearance && (!allowBossBodyClearance || value.Mode != BossPlacementMode.Surface || value.FailurePolicy != BossPlacementFailurePolicy.SkipAction || value.SocketPath != null || value.LocalOffset.x != 0f || value.LocalOffset.z != 0f || value.LocalOffset.y > 0f))
			{
				AddIssue(issues, "placement.invalid_body_clearance_context", path + ".useBossBodyClearance", "Body clearance is supported only for Surface replacement catches with SkipAction, no socket, and a non-positive vertical-only LocalOffset.");
			}
			if (!Enum.IsDefined(typeof(BossPlacementMode), value.Mode))
			{
				AddIssue(issues, "placement.unsupported_mode", path + ".mode", "Placement Mode is not supported.");
			}
			else if (!allowBossRelative && value.Mode == BossPlacementMode.BossRelative)
			{
				AddIssue(issues, "placement.invalid_context", path + ".mode", "BossRelative placement cannot be used before the boss exists.");
			}
			if (!Enum.IsDefined(typeof(BossPlacementFailurePolicy), value.FailurePolicy))
			{
				AddIssue(issues, "placement.unsupported_failure_policy", path + ".failurePolicy", "Placement FailurePolicy is not supported.");
			}
			if (!IsFinite(value.LocalOffset) || !IsWithinMagnitude(value.LocalOffset, 1000f))
			{
				AddIssue(issues, "placement.invalid_offset", path + ".localOffset", $"Placement LocalOffset must be finite and bounded by {1000f}.");
			}
			if (!IsFinite(value.SearchRadius) || value.SearchRadius < 0f || value.SearchRadius > 1000f)
			{
				AddIssue(issues, "placement.invalid_search_radius", path + ".searchRadius", $"Placement SearchRadius must be between 0 and {1000f}.");
			}
			if (!IsFinite(value.VerticalSearchDistance) || value.VerticalSearchDistance < 0f || value.VerticalSearchDistance > 1000f)
			{
				AddIssue(issues, "placement.invalid_vertical_search", path + ".verticalSearchDistance", $"Placement VerticalSearchDistance must be between 0 and {1000f}.");
			}
			if (!IsFinite(value.ClearanceRadius) || value.ClearanceRadius < 0f || value.ClearanceRadius > 1000f)
			{
				AddIssue(issues, "placement.invalid_clearance", path + ".clearanceRadius", $"Placement ClearanceRadius must be between 0 and {1000f}.");
			}
			if (value.MaximumAttempts <= 0 || value.MaximumAttempts > 32)
			{
				AddIssue(issues, "placement.invalid_attempt_limit", path + ".maximumAttempts", $"Placement MaximumAttempts must be between 1 and {32}.");
			}
			if (value.Mode == BossPlacementMode.TransformSocket)
			{
				if (!IsSafeRelativePath(value.SocketPath))
				{
					AddIssue(issues, "placement.invalid_socket", path + ".socketPath", "TransformSocket placement requires a safe relative SocketPath.");
				}
			}
			else if (value.SocketPath != null)
			{
				AddIssue(issues, "placement.unused_socket", path + ".socketPath", "SocketPath may only be supplied for TransformSocket mode.");
			}
		}

		private static void ValidateFormation(BossFormationDefinition? value, int count, string path, ICollection<BossValidationIssue> issues)
		{
			if (value == null)
			{
				return;
			}
			if (!Enum.IsDefined(typeof(BossFormationKind), value.Kind))
			{
				AddIssue(issues, "formation.unsupported_kind", path + ".kind", "Formation Kind is not supported.");
			}
			if (!IsFinite(value.Radius) || value.Radius < 0f || value.Radius > 1000f)
			{
				AddIssue(issues, "formation.invalid_radius", path + ".radius", $"Formation Radius must be between 0 and {1000f}.");
			}
			if (!IsFinite(value.Spacing) || value.Spacing <= 0f || value.Spacing > 1000f)
			{
				AddIssue(issues, "formation.invalid_spacing", path + ".spacing", $"Formation Spacing must be between 0 (exclusive) and {1000f}.");
			}
			if (!IsFinite(value.AngleDegrees) || value.AngleDegrees <= 0f || value.AngleDegrees > 360f)
			{
				AddIssue(issues, "formation.invalid_angle", path + ".angleDegrees", "Formation AngleDegrees must be between 0 (exclusive) and 360.");
			}
			if (!IsFinite(value.YawOffsetDegrees) || Math.Abs(value.YawOffsetDegrees) > 36000f)
			{
				AddIssue(issues, "formation.invalid_yaw", path + ".yawOffsetDegrees", "Formation YawOffsetDegrees must be finite and bounded by 36000 degrees.");
			}
			if (value.SocketPaths == null)
			{
				AddIssue(issues, "formation.missing_sockets", path + ".socketPaths", "Formation SocketPaths cannot be null; use an empty collection.");
				return;
			}
			if (value.SocketPaths.Count > 32)
			{
				AddIssue(issues, "formation.socket_budget_exceeded", path + ".socketPaths", $"Formation may contain at most {32} socket paths.");
			}
			if (value.Kind == BossFormationKind.Sockets && value.SocketPaths.Count != count)
			{
				AddIssue(issues, "formation.socket_count_mismatch", path + ".socketPaths", "Sockets formation requires exactly one SocketPath per requested minion.");
			}
			if (value.Kind != BossFormationKind.Sockets && value.SocketPaths.Count != 0)
			{
				AddIssue(issues, "formation.unused_sockets", path + ".socketPaths", "SocketPaths may only be supplied for a Sockets formation.");
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < Math.Min(value.SocketPaths.Count, 32); i++)
			{
				string text = value.SocketPaths[i];
				if (!IsSafeRelativePath(text))
				{
					AddIssue(issues, "formation.invalid_socket", path + ".socketPaths[" + i + "]", "Every formation SocketPath must be a safe relative transform path.");
				}
				else if (!hashSet.Add(text))
				{
					AddIssue(issues, "formation.duplicate_socket", path + ".socketPaths[" + i + "]", "Duplicate formation SocketPath '" + text + "'.");
				}
			}
			if ((value.Kind == BossFormationKind.Ring || value.Kind == BossFormationKind.Cone) && value.Radius <= 0f)
			{
				AddIssue(issues, "formation.invalid_radius", path + ".radius", "Ring and Cone formations require a positive Radius.");
			}
		}

		private static bool IsSafeRelativePath(string? value)
		{
			if (!string.IsNullOrWhiteSpace(value) && value.Length <= 1024 && string.Equals(value, value.Trim(), StringComparison.Ordinal) && !value.StartsWith("/", StringComparison.Ordinal) && !value.StartsWith("\\", StringComparison.Ordinal) && !value.Contains(".."))
			{
				return EncounterContractValidation.IsSafeToken(value, 1024);
			}
			return false;
		}

		private static void ValidateAbility(BossAbilityDefinition? ability, string phaseId, ISet<string> abilityIds, ICollection<string> errors, ref long declaredActiveMinions, ref long declaredExecutionClaims, bool isGlobal)
		{
			if (ability == null)
			{
				errors.Add("Phase '" + phaseId + "' contains a null ability.");
				return;
			}
			if (!EncounterContractValidation.IsSafeToken(ability.Id, 128))
			{
				errors.Add($"Every ability requires a normalized, control-free Id no longer than {128} characters.");
			}
			else if (!abilityIds.Add(ability.Id))
			{
				errors.Add("Duplicate ability Id '" + ability.Id + "'.");
			}
			if (!Enum.IsDefined(typeof(BossAbilityTrigger), ability.Trigger))
			{
				errors.Add("Ability '" + ability.Id + "' Trigger is not supported.");
			}
			else if (isGlobal && ability.Trigger == BossAbilityTrigger.PhaseEnter)
			{
				errors.Add("Global ability '" + ability.Id + "' cannot use PhaseEnter; place it on a phase.");
			}
			else if (!isGlobal && ability.Trigger == BossAbilityTrigger.OnSpawn)
			{
				errors.Add("Phase ability '" + ability.Id + "' cannot use OnSpawn; place it in BossDefinition.Abilities.");
			}
			if (!IsFinite(ability.InitialDelaySeconds) || ability.InitialDelaySeconds < 0f || ability.InitialDelaySeconds > 3600f)
			{
				errors.Add($"Ability '{ability.Id}' InitialDelaySeconds must be between 0 and {3600f}.");
			}
			if (!IsFinite(ability.CooldownSeconds) || ability.CooldownSeconds < 0f || ability.CooldownSeconds > 86400f)
			{
				errors.Add($"Ability '{ability.Id}' CooldownSeconds must be between 0 and {86400f}.");
			}
			if (ability.MaxRepeats < 0 || ability.MaxRepeats > 1024)
			{
				errors.Add($"Ability '{ability.Id}' MaxRepeats must be between 0 and {1024}.");
			}
			if (ability.MaxRepeats > 0 && (!IsFinite(ability.CooldownSeconds) || ability.CooldownSeconds <= 0f))
			{
				errors.Add("Ability '" + ability.Id + "' requires a positive CooldownSeconds when MaxRepeats is positive.");
			}
			if (!IsFinite(ability.Probability) || ability.Probability < 0f || ability.Probability > 1f)
			{
				errors.Add("Ability '" + ability.Id + "' Probability must be between 0 and 1.");
			}
			ValidateTimeline(ability.Id, ability.Timeline, errors);
			ValidateTargetSelector(ability.Id, ability.TargetSelector, errors);
			ValidateGeometry(ability.Id, ability.Geometry, errors);
			ValidateTelegraph(ability.Id, ability.Telegraph, errors);
			if (ability.Actions == null)
			{
				errors.Add("Ability '" + ability.Id + "' Actions cannot be null; use an empty collection.");
			}
			else if (ability.Actions.Count > 32)
			{
				errors.Add($"Ability '{ability.Id}' may declare at most {32} actions.");
			}
			IReadOnlyList<BossActionDefinition> readOnlyList = ability.Actions ?? Array.Empty<BossActionDefinition>();
			if (ability.Probability > 0f)
			{
				int num = Math.Min(Math.Max(ability.MaxRepeats, 0), 1024);
				declaredExecutionClaims += ((long)num + 1L) * Math.Min(readOnlyList.Count, 32);
			}
			for (int i = 0; i < Math.Min(readOnlyList.Count, 32); i++)
			{
				ValidateAction(readOnlyList[i], phaseId + "/" + ability.Id, errors, ref declaredActiveMinions, isAbilityAction: true);
				if (ability.Timeline != null)
				{
					ValidateAbilityActionTimeline(ability.Id, readOnlyList[i], ability.Timeline, errors);
				}
			}
		}

		private static void ValidateVersion4(BossDefinition definition, ICollection<BossValidationIssue> issues)
		{
			ValidateVersion4VanillaIntegration(definition.VanillaIntegration, issues);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			IReadOnlyList<BossAbilityDefinition> readOnlyList = definition.Abilities ?? Array.Empty<BossAbilityDefinition>();
			for (int i = 0; i < Math.Min(readOnlyList.Count, 32); i++)
			{
				BossAbilityDefinition bossAbilityDefinition = readOnlyList[i];
				if (bossAbilityDefinition != null && EncounterContractValidation.IsSafeToken(bossAbilityDefinition.Id, 128))
				{
					hashSet.Add(bossAbilityDefinition.Id);
				}
			}
			IReadOnlyList<BossPhaseDefinition> readOnlyList2 = definition.Phases ?? Array.Empty<BossPhaseDefinition>();
			for (int j = 0; j < Math.Min(readOnlyList2.Count, 32); j++)
			{
				BossPhaseDefinition bossPhaseDefinition = readOnlyList2[j];
				if (bossPhaseDefinition == null)
				{
					continue;
				}
				IReadOnlyList<BossAbilityDefinition> readOnlyList3 = bossPhaseDefinition.Abilities ?? Array.Empty<BossAbilityDefinition>();
				for (int k = 0; k < Math.Min(readOnlyList3.Count, 32); k++)
				{
					BossAbilityDefinition bossAbilityDefinition2 = readOnlyList3[k];
					if (bossAbilityDefinition2 != null && EncounterContractValidation.IsSafeToken(bossAbilityDefinition2.Id, 128))
					{
						hashSet.Add(bossAbilityDefinition2.Id);
					}
				}
			}
			HashSet<string> actionIds = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> modifierIds = new HashSet<string>(StringComparer.Ordinal);
			int totalConditionNodes = 0;
			int reversibleModifiers = 0;
			if (definition.Encounter != null)
			{
				ValidateHookStagger(definition.Encounter.HookStagger, "encounter.hookStagger", issues);
				IReadOnlyList<BossCatchTriggerDefinition> readOnlyList4 = definition.Encounter.CatchTriggers ?? Array.Empty<BossCatchTriggerDefinition>();
				for (int l = 0; l < Math.Min(readOnlyList4.Count, 32); l++)
				{
					if (readOnlyList4[l] != null)
					{
						ValidatePlacement(readOnlyList4[l].Placement, "encounter.catchTriggers[" + l + "].placement", issues, allowBossRelative: false, allowBossBodyClearance: true);
					}
				}
			}
			IReadOnlyList<BossAbilityDefinition> readOnlyList5 = definition.Abilities ?? Array.Empty<BossAbilityDefinition>();
			for (int m = 0; m < Math.Min(readOnlyList5.Count, 32); m++)
			{
				ValidateVersion4Ability(readOnlyList5[m], "abilities[" + m + "]", null, hashSet, actionIds, modifierIds, issues, ref totalConditionNodes, ref reversibleModifiers);
			}
			IReadOnlyList<BossPhaseDefinition> readOnlyList6 = definition.Phases ?? Array.Empty<BossPhaseDefinition>();
			for (int n = 0; n < Math.Min(readOnlyList6.Count, 32); n++)
			{
				BossPhaseDefinition bossPhaseDefinition2 = readOnlyList6[n];
				if (bossPhaseDefinition2 != null)
				{
					string text = "phases[" + n + "]";
					if (bossPhaseDefinition2.ExitActions == null)
					{
						AddIssue(issues, "phase.missing_exit_actions", text + ".exitActions", "ExitActions cannot be null; use an empty collection.");
					}
					else if (bossPhaseDefinition2.ExitActions.Count > 32)
					{
						AddIssue(issues, "phase.exit_action_budget_exceeded", text + ".exitActions", $"A phase may declare at most {32} exit actions.");
					}
					ValidateVersion4Actions(bossPhaseDefinition2.Actions, text + ".actions", bossPhaseDefinition2.Id, null, isExit: false, actionIds, modifierIds, issues, ref reversibleModifiers);
					ValidateVersion4Actions(bossPhaseDefinition2.ExitActions, text + ".exitActions", bossPhaseDefinition2.Id, null, isExit: true, actionIds, modifierIds, issues, ref reversibleModifiers);
					IReadOnlyList<BossAbilityDefinition> readOnlyList7 = bossPhaseDefinition2.Abilities ?? Array.Empty<BossAbilityDefinition>();
					for (int num = 0; num < Math.Min(readOnlyList7.Count, 32); num++)
					{
						ValidateVersion4Ability(readOnlyList7[num], text + ".abilities[" + num + "]", bossPhaseDefinition2.Id, hashSet, actionIds, modifierIds, issues, ref totalConditionNodes, ref reversibleModifiers);
					}
				}
			}
			if (reversibleModifiers > 64)
			{
				AddIssue(issues