using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CrestsEvolve.Bootstrap;
using CrestsEvolve.Core.Balance;
using CrestsEvolve.Core.Buffs;
using CrestsEvolve.Core.Charms;
using CrestsEvolve.Core.Combat;
using CrestsEvolve.Core.Events;
using CrestsEvolve.Core.Infrastructure;
using CrestsEvolve.Core.Input;
using CrestsEvolve.Core.Random;
using CrestsEvolve.Core.Time;
using CrestsEvolve.Core.Tools;
using CrestsEvolve.Core.UI;
using CrestsEvolve.Features;
using CrestsEvolve.Features.StatusIcons;
using CrestsEvolve.Features.Tools;
using CrestsEvolve.GameInterop;
using CrestsEvolve.GameInterop.Binding;
using CrestsEvolve.GameInterop.Input;
using CrestsEvolve.GameInterop.Patches;
using CrestsEvolve.GameInterop.Reflection;
using CrestsEvolve.UI;
using GlobalEnums;
using GlobalSettings;
using HarmonyLib;
using HutongGames.PlayMaker;
using InControl;
using Microsoft.CodeAnalysis;
using Needleforge;
using Needleforge.Data;
using Newtonsoft.Json;
using TeamCherry.Localization;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("CrestsEvolve.LegendsNeverDie")]
[assembly: InternalsVisibleTo("CrestsEvolve.RageOfTheGoner")]
[assembly: InternalsVisibleTo("CrestsEvolve.ToolsAscension")]
[assembly: InternalsVisibleTo("CrestsEvolve.InsectMayCry")]
[assembly: InternalsVisibleTo("CrestsEvolve.Core.Tests")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("CrestsEvolve")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+757e75a2d4534028308600b7117b47c56eb48037")]
[assembly: AssemblyProduct("CrestsEvolve")]
[assembly: AssemblyTitle("CrestsEvolve")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.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;
		}
	}
	internal static class IsExternalInit
	{
	}
}
namespace CrestsEvolve
{
	[BepInPlugin("local.crestsevolve", "CrestsEvolve", "0.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "local.crestsevolve";

		public const string PluginName = "CrestsEvolve";

		public const string PluginVersion = "0.1.0";

		private Harmony? _harmony;

		private ModBootstrap? _bootstrap;

		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("local.crestsevolve");
			_bootstrap = new ModBootstrap(((BaseUnityPlugin)this).Logger, ((BaseUnityPlugin)this).Config, _harmony);
			_bootstrap.Start();
		}

		private void OnDestroy()
		{
			try
			{
				_bootstrap?.Dispose();
			}
			finally
			{
				Harmony? harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
		}
	}
}
namespace CrestsEvolve.UI
{
	public sealed class LogStatusIconPresenter : IStatusIconPresenter
	{
		private readonly ManualLogSource _log;

		public static bool Verbose { get; set; }

		public LogStatusIconPresenter(ManualLogSource log)
		{
			_log = log;
		}

		public void Present(StatusIconProjection projection)
		{
			if (Verbose)
			{
				_log.LogDebug((object)($"[StatusIcons] rev={projection.Revision} " + string.Join("; ", projection.Icons.Select((StatusIconState i) => $"{i.Key}={i.Current}/{i.Max}"))));
			}
		}

		public void Hide()
		{
			_log.LogDebug((object)"[StatusIcons] hidden");
		}
	}
	public sealed class LogUiPresenter : IUiPresenter
	{
		private readonly ManualLogSource _log;

		public static bool Verbose { get; set; }

		public LogUiPresenter(ManualLogSource log)
		{
			_log = log;
		}

		public void Present(UiProjection projection)
		{
			if (Verbose)
			{
				_log.LogDebug((object)($"[UiProjection] crest={projection.CrestId} rev={projection.Revision} " + $"stacks={projection.EnhancementStacks} remaining={projection.RemainingSeconds:F1} " + $"rage={projection.Rage} superRage={projection.SuperRage} special={projection.SpecialMode} " + $"charmOffset={projection.CharmLevelOffset} shield={projection.SilkShieldRemaining} " + $"rageRemaining={projection.RageRemainingSeconds:F1}"));
			}
		}

		public void Hide()
		{
			if (Verbose)
			{
				_log.LogDebug((object)"[UiProjection] hidden");
			}
		}
	}
	public sealed record StatusIconState(string Key, int Current, int Max, bool Visible = true, string? ColorOverride = null, string? CenterText = null, bool Dimmed = false);
	public sealed record StatusIconProjection(long Revision, IReadOnlyList<StatusIconState> Icons);
	public interface IStatusIconPresenter
	{
		void Present(StatusIconProjection projection);

		void Hide();
	}
	public sealed class StatusIconProjector : IDisposable
	{
		private readonly StatusIconLedger _ledger;

		private readonly IStatusIconPresenter _presenter;

		private long _lastRevision = -1L;

		public static StatusIconProjector? Current { get; private set; }

		public StatusIconProjector(StatusIconLedger ledger, IStatusIconPresenter presenter)
		{
			_ledger = ledger ?? throw new ArgumentNullException("ledger");
			_presenter = presenter ?? throw new ArgumentNullException("presenter");
			if (Current != null)
			{
				throw new InvalidOperationException("A StatusIconProjector is already active.");
			}
			Current = this;
			_ledger.Changed += OnChanged;
			OnChanged(_ledger.Snapshot());
		}

		public void Refresh()
		{
			StatusIconSnapshot statusIconSnapshot = _ledger.Snapshot();
			_lastRevision = statusIconSnapshot.Revision;
			Present(statusIconSnapshot);
		}

		private void OnChanged(StatusIconSnapshot snapshot)
		{
			if (snapshot.Revision != _lastRevision)
			{
				_lastRevision = snapshot.Revision;
				Present(snapshot);
			}
		}

		private void Present(StatusIconSnapshot snapshot)
		{
			List<StatusIconState> list = new List<StatusIconState>(snapshot.Icons.Count);
			foreach (StatusIconValue icon in snapshot.Icons)
			{
				bool flag = icon.Visible;
				if (flag && icon.Current <= 0 && !StatusIconProjectionRules.ZeroValueVisible(icon.Key))
				{
					flag = false;
				}
				list.Add(new StatusIconState(icon.Key, icon.Current, icon.Max, flag, icon.ColorOverride, icon.Text, icon.Dimmed));
			}
			_presenter.Present(new StatusIconProjection(snapshot.Revision, list));
		}

		public void Dispose()
		{
			if (Current == this)
			{
				Current = null;
			}
			_ledger.Changed -= OnChanged;
			_presenter.Hide();
		}
	}
	public sealed class CompositeStatusIconPresenter : IStatusIconPresenter
	{
		private readonly IStatusIconPresenter _always;

		private readonly Func<IStatusIconPresenter?> _dynamic;

		public CompositeStatusIconPresenter(IStatusIconPresenter always, Func<IStatusIconPresenter?> dynamic)
		{
			_always = always ?? throw new ArgumentNullException("always");
			_dynamic = dynamic ?? throw new ArgumentNullException("dynamic");
		}

		public void Present(StatusIconProjection projection)
		{
			_always.Present(projection);
			_dynamic()?.Present(projection);
		}

		public void Hide()
		{
			_always.Hide();
			_dynamic()?.Hide();
		}
	}
	public sealed record UiProjection(string CrestId, int EnhancementStacks, double RemainingSeconds, double NormalAttackDamage, bool Rage, bool SuperRage, bool SpecialMode, int CharmLevelOffset, int SilkShieldRemaining, double RageRemainingSeconds, long Revision);
	public interface IUiPresenter
	{
		void Present(UiProjection projection);

		void Hide();
	}
}
namespace CrestsEvolve.GameInterop
{
	public static class ArchitectRuneBridge
	{
		public static Func<bool> IsToolRepairActive { get; set; } = () => false;

		public static Func<bool> IsToolTransformActive { get; set; } = () => false;
	}
	public static class AttackKindMapping
	{
		public static AttackKind FromAttackType(AttackTypes attackType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected I4, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			switch ((int)attackType)
			{
			default:
				if ((int)attackType != 16)
				{
					break;
				}
				return AttackKind.Charge;
			case 0:
				return AttackKind.Normal;
			case 1:
				return AttackKind.Normal;
			case 2:
				return AttackKind.Skill;
			case 10:
				return AttackKind.Skill;
			case 6:
				return AttackKind.Dash;
			case 7:
				return AttackKind.Projectile;
			case 11:
				return AttackKind.Additional;
			case 3:
			case 4:
			case 5:
			case 8:
			case 9:
				break;
			}
			return AttackKind.Additional;
		}
	}
	public static class BeastRuneBridge
	{
		public static Func<bool> IsEnhancementActive { get; set; } = () => false;

		public static Func<bool> IsDamageProtectActive { get; set; } = () => false;

		public static Func<bool> IsPredatorCharged { get; set; } = () => false;

		public static Action? AcquireChargeSlashInvulnerability { get; set; }
	}
	public sealed class BeastStateAccessor
	{
		private readonly ManualLogSource _log;

		private readonly FieldInfo? _warriorStateField;

		private bool _warned;

		public BeastStateAccessor(ManualLogSource log)
		{
			_log = log;
			_warriorStateField = AccessTools.Field(typeof(HeroController), "warriorState");
			if (_warriorStateField == null)
			{
				_log.LogWarning((object)"[BeastState] warriorState field not found; kill duration extension disabled.");
			}
		}

		public void AddRageTime(float seconds, float max)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (_warriorStateField == null || seconds <= 0f)
			{
				return;
			}
			try
			{
				HeroController instance = HeroController.instance;
				if (!((Object)(object)instance == (Object)null))
				{
					WarriorCrestStateInfo val = (WarriorCrestStateInfo)_warriorStateField.GetValue(instance);
					if (val.IsInRageMode)
					{
						val.RageEffectTimeLeft = Math.Min(max, val.RageEffectTimeLeft + seconds);
						_warriorStateField.SetValue(instance, val);
					}
				}
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
			}
		}

		public bool IsInRageMode()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (_warriorStateField == null)
			{
				return false;
			}
			HeroController instance = HeroController.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			try
			{
				return ((WarriorCrestStateInfo)_warriorStateField.GetValue(instance)).IsInRageMode;
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
				return false;
			}
		}

		public void SetRageStateActive(bool active)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (!active || _warriorStateField == null)
			{
				return;
			}
			HeroController instance = HeroController.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			try
			{
				WarriorCrestStateInfo val = (WarriorCrestStateInfo)_warriorStateField.GetValue(instance);
				val.IsInRageMode = true;
				val.RageEffectTimeLeft = Gameplay.WarriorRageDuration;
				val.RageHealTimeLeft = Gameplay.WarriorRageDuration + Gameplay.WarriorRageGraceTime;
				_warriorStateField.SetValue(instance, val);
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
			}
		}

		public void SetRageHealBlocked(bool blocked)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (!blocked || _warriorStateField == null)
			{
				return;
			}
			HeroController instance = HeroController.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			try
			{
				WarriorCrestStateInfo val = (WarriorCrestStateInfo)_warriorStateField.GetValue(instance);
				val.RageModeHealCount = instance.GetRageModeHealCap();
				_warriorStateField.SetValue(instance, val);
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
			}
		}

		private void WarnOnce(Exception ex)
		{
			if (!_warned)
			{
				_warned = true;
				_log.LogWarning((object)("[BeastState] access failed (" + ex.GetType().Name + ": " + ex.Message + "); suppressing further warnings."));
			}
		}
	}
	public static class CloaklessRuneBridge
	{
		public static Func<bool> IsFreeBindCharged { get; set; } = () => false;

		public static Func<bool> TryConsumeFreeBind { get; set; } = () => false;

		public static Func<bool> IsGlacialAugmentCharged { get; set; } = () => false;

		public static Func<bool> TryConsumeGlacialAugment { get; set; } = () => false;
	}
	public static class CursedRuneBridge
	{
		private sealed class NullLease : IDisposable
		{
			public void Dispose()
			{
			}
		}

		public static Func<bool> IsBindEnabled { get; set; } = () => false;

		public static Func<bool> IsBindInvulnerabilityActive { get; set; } = () => false;

		public static Func<IDisposable> AcquireBindInvulnerability { get; set; } = () => new NullLease();

		public static Func<double> BindInvulnerabilitySeconds { get; set; } = () => 2.0;
	}
	public sealed class DashStateAccessor
	{
		private readonly ManualLogSource _log;

		private bool _warned;

		public DashStateAccessor(ManualLogSource log)
		{
			_log = log ?? throw new ArgumentNullException("log");
		}

		public bool IsDashSprintActive()
		{
			try
			{
				HeroController instance = HeroController.instance;
				if ((Object)(object)instance == (Object)null || instance.cState == null)
				{
					return false;
				}
				if (instance.cState.isSprinting || instance.cState.dashing)
				{
					return IsDashPressed();
				}
				return false;
			}
			catch (Exception ex)
			{
				if (!_warned)
				{
					_warned = true;
					_log.LogWarning((object)("[DashState] dash sprint query failed: " + ex.Message));
				}
				return false;
			}
		}

		private static bool IsDashPressed()
		{
			InputHandler instance = ManagerSingleton<InputHandler>.Instance;
			if ((Object)(object)instance == (Object)null || instance.inputActions == null || instance.inputActions.Dash == null)
			{
				return true;
			}
			return ((OneAxisInputControl)instance.inputActions.Dash).IsPressed;
		}
	}
	public sealed class FleaBrewApplicator
	{
		public const string FleaBrewToolId = "Flea Brew";

		private readonly ManualLogSource _log;

		private readonly BuffState _buff;

		private bool _warned;

		public bool IsBrewActive => _buff.IsActive;

		public double BrewRemainingSeconds => _buff.RemainingSeconds;

		public FleaBrewApplicator(ManualLogSource log, IClock clock, double durationSeconds = 3.0)
		{
			_log = log ?? throw new ArgumentNullException("log");
			if (durationSeconds <= 0.0)
			{
				throw new ArgumentOutOfRangeException("durationSeconds");
			}
			_buff = new BuffState(BuffKind.Meade, 1, durationSeconds, clock ?? throw new ArgumentNullException("clock"));
		}

		public void Apply()
		{
			if (!TryApplyVanilla())
			{
				_buff.Add();
				WarnOnce("vanilla Flea Brew application path is unconfirmed; fell back to internal buff timer (U).");
			}
		}

		private bool TryApplyVanilla()
		{
			try
			{
				ToolItem toolByName = ToolItemManager.GetToolByName("Flea Brew");
				if ((Object)(object)toolByName == (Object)null)
				{
					return false;
				}
				_log.LogInfo((object)("[FleaBrew][probe] tool='" + toolByName.name + "' type='" + ((object)toolByName).GetType().FullName + "' (U; FSM/object path pending probe, no event sent until confirmed)."));
				return false;
			}
			catch (Exception ex)
			{
				WarnOnce(ex.Message);
				return false;
			}
		}

		private void WarnOnce(string message)
		{
			if (!_warned)
			{
				_warned = true;
				_log.LogWarning((object)("[FleaBrew] " + message));
			}
		}
	}
	public static class FracturedMaskBridge
	{
		public static Func<bool>? IsEquipped { get; set; } = () => false;

		public static Func<bool>? TryRepair { get; set; } = () => false;
	}
	public sealed class GameEventPatches : IDisposable
	{
		private readonly ManualLogSource _log;

		private readonly GameEventHub _events;

		private readonly DynamicPatchResolver _resolver;

		private readonly Harmony _harmony;

		private readonly DamageNegotiationService _negotiation;

		private readonly IGameApi _game;

		private readonly List<string> _installed = new List<string>();

		private static GameEventPatches? _active;

		private static readonly FieldInfo LastHitInstanceField = AccessTools.Field(typeof(HealthManager), "lastHitInstance");

		private static bool _spellKillWarned;

		private static readonly (string BindingId, string? Prefix, string? Postfix)[] EventBindings = new(string, string, string)[14]
		{
			("player.attack.resolved", null, "NailHitEnemyPostfix"),
			("enemy.damage.resolved", null, "ApplyDamageScalingPostfix"),
			("player.damage.before", "TakeDamagePrefix", null),
			("player.damage.after", null, "TakeDamagePostfix"),
			("player.heal.request", "AddHealthPrefix", null),
			("player.heal.resolved", null, "AddHealthPostfix"),
			("player.silk.get", "AddSilkPrefix", "AddSilkPostfix"),
			("player.silk.spend", "TakeSilkPrefix", "TakeSilkPostfix"),
			("player.crest.changed", null, "SendEquippedChangedEventPostfix"),
			("enemy.killed", null, "SendDeathEventPostfix"),
			("player.bench.rested", null, "SetOnBenchPostfix"),
			("player.died", "DiePrefix", null),
			("scene.changed", null, "SceneInitPostfix"),
			("player.reaper.bind.completed", null, "BindCompletedPostfix")
		};

		private static string? _lastCrestId;

		private static bool _benchWasOnBench;

		public GameEventPatches(ManualLogSource log, GameEventHub events, DynamicPatchResolver resolver, Harmony harmony, DamageNegotiationService negotiation, IGameApi game)
		{
			_log = log;
			_events = events;
			_resolver = resolver;
			_harmony = harmony;
			_negotiation = negotiation;
			_game = game;
		}

		public void Install()
		{
			_active = this;
			_benchWasOnBench = false;
			(string, string, string)[] eventBindings = EventBindings;
			for (int i = 0; i < eventBindings.Length; i++)
			{
				(string, string, string) tuple = eventBindings[i];
				if (tuple.Item2 != null && tuple.Item3 != null)
				{
					PatchBoth(tuple.Item1, tuple.Item2, tuple.Item3);
				}
				else if (tuple.Item2 != null)
				{
					PatchPrefix(tuple.Item1, tuple.Item2);
				}
				else
				{
					PatchPostfix(tuple.Item1, tuple.Item3);
				}
			}
			_log.LogInfo((object)("Game event patches installed: " + string.Join(", ", _installed)));
		}

		public void Dispose()
		{
			_active = null;
			_benchWasOnBench = false;
			_installed.Clear();
		}

		private void PatchPrefix(string bindingId, string patchMethod)
		{
			PatchWith(bindingId, delegate(MethodBase method)
			{
				_harmony.Patch(method, HarmonyMethod(patchMethod), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			});
		}

		private void PatchPostfix(string bindingId, string patchMethod)
		{
			PatchWith(bindingId, delegate(MethodBase method)
			{
				_harmony.Patch(method, (HarmonyMethod)null, HarmonyMethod(patchMethod), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			});
		}

		private void PatchBoth(string bindingId, string prefixMethod, string postfixMethod)
		{
			PatchWith(bindingId, delegate(MethodBase method)
			{
				_harmony.Patch(method, HarmonyMethod(prefixMethod), HarmonyMethod(postfixMethod), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			});
		}

		private void PatchWith(string bindingId, Action<MethodBase> apply)
		{
			MethodBase methodBase = _resolver.Resolve(bindingId);
			if ((object)methodBase == null)
			{
				_log.LogWarning((object)("Event patch disabled (binding unresolved): " + bindingId));
				return;
			}
			apply(methodBase);
			_installed.Add(bindingId);
			_log.LogInfo((object)("Event patch installed: " + bindingId + " -> " + GeneralExtensions.FullDescription(methodBase)));
		}

		private static HarmonyMethod HarmonyMethod(string name)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			return new HarmonyMethod(AccessTools.DeclaredMethod(typeof(GameEventPatches), name, (Type[])null, (Type[])null) ?? throw new MissingMethodException(typeof(GameEventPatches).FullName, name));
		}

		private unsafe static void NailHitEnemyPostfix(HeroController __instance, HealthManager enemyHealth, HitInstance hitInstance)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			_active?._events.Publish(new AttackEvent(((long)Time.frameCount << 16) ^ ((Object)enemyHealth).GetInstanceID(), ((Object)__instance).GetInstanceID(), ((Object)enemyHealth).GetInstanceID(), AttackKindMapping.FromAttackType(hitInstance.AttackType), "attack." + ((object)(*(AttackTypes*)(&hitInstance.AttackType))/*cast due to .constrained prefix*/).ToString(), hitInstance.DamageDealt, (!hitInstance.IsFirstHit) ? 1 : 0, IsAdditionalDamage: false, IsHeroDamage: true, ((Component)enemyHealth).transform.position.x, ((Component)enemyHealth).transform.position.y, ((Component)enemyHealth).transform.position.z));
		}

		private unsafe static void ApplyDamageScalingPostfix(HealthManager __instance, HitInstance hitInstance, HitInstance __result)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			_active?._events.PublishEnemyDamageResolved(new AttackEvent(((long)Time.frameCount << 16) ^ ((Object)__instance).GetInstanceID(), ((Object)(object)hitInstance.Source != (Object)null) ? ((Object)hitInstance.Source).GetInstanceID() : 0, ((Object)__instance).GetInstanceID(), AttackKindMapping.FromAttackType(hitInstance.AttackType), "enemy.damage." + ((object)(*(AttackTypes*)(&hitInstance.AttackType))/*cast due to .constrained prefix*/).ToString(), __result.DamageDealt, (!__result.IsFirstHit) ? 1 : 0, IsAdditionalDamage: false, hitInstance.IsHeroDamage, ((Component)__instance).transform.position.x, ((Component)__instance).transform.position.y, ((Component)__instance).transform.position.z));
		}

		private unsafe static bool TakeDamagePrefix(ref int damageAmount, HazardType hazardType)
		{
			GameEventPatches active = _active;
			if (active == null || damageAmount <= 0)
			{
				return true;
			}
			active._events.PublishBefore(new PlayerDamageEvent(damageAmount, "hazard." + ((object)(*(HazardType*)(&hazardType))/*cast due to .constrained prefix*/).ToString()));
			int num = damageAmount;
			DamageDecision damageDecision = active._negotiation.Negotiate(num, "hazard." + ((object)(*(HazardType*)(&hazardType))/*cast due to .constrained prefix*/).ToString());
			if (damageDecision.SilkToSpend > 0)
			{
				active._game.TrySpendSilk(damageDecision.SilkToSpend, damageDecision.Reason ?? "damage-negotiation");
			}
			damageAmount = damageDecision.RemainingMaskDamage;
			if (damageDecision.Verdict != DamageVerdict.Allow || damageAmount <= 0)
			{
				active._log.LogInfo((object)("Damage cancelled by negotiation: " + (damageDecision.Reason ?? "unknown") + " " + $"(incoming={num}, remaining={damageDecision.RemainingMaskDamage}, silk={damageDecision.SilkToSpend})"));
				return false;
			}
			return true;
		}

		private unsafe static void TakeDamagePostfix(int damageAmount, HazardType hazardType)
		{
			GameEventPatches active = _active;
			if (active != null && damageAmount > 0)
			{
				active._events.PublishAfter(new PlayerDamageEvent(damageAmount, "hazard." + ((object)(*(HazardType*)(&hazardType))/*cast due to .constrained prefix*/).ToString()));
			}
		}

		private static bool AddHealthPrefix(HeroController __instance, int amount, ref int __state)
		{
			GameEventPatches active = _active;
			if (active == null || amount <= 0)
			{
				return true;
			}
			PlayerData val = __instance?.playerData;
			int num = val?.health ?? 0;
			int missingWhiteHealth = Math.Max(0, Math.Max(1, val?.maxHealth ?? 0) - num);
			__state = num;
			HealEvent healEvent = new HealEvent(amount, 0, "heal.addhealth", missingWhiteHealth);
			active._events.PublishRequested(healEvent);
			if (active._events.InterceptHeal(healEvent))
			{
				active._log.LogInfo((object)$"[Heal] consumed by interceptor (amount={amount})");
				return false;
			}
			return true;
		}

		private static void AddHealthPostfix(HeroController __instance, int amount, ref int __state)
		{
			GameEventPatches active = _active;
			if (active != null && amount > 0)
			{
				PlayerData val = __instance?.playerData;
				int num = __state;
				int num2 = val?.health ?? num;
				int applied = Math.Max(0, num2 - num);
				int missingWhiteHealth = Math.Max(0, Math.Max(1, val?.maxHealth ?? 0) - num);
				active._events.PublishResolved(new HealEvent(amount, applied, "heal.addhealth", missingWhiteHealth));
			}
		}

		private static void AddSilkPrefix(HeroController __instance, ref int __state)
		{
			__state = __instance.playerData?.silk ?? 0;
		}

		private unsafe static void AddSilkPostfix(HeroController __instance, SilkAddSource source, int __state)
		{
			GameEventPatches active = _active;
			int num = __instance.playerData?.silk ?? 0;
			if (active != null && num != __state)
			{
				active._events.Publish(new ResourceEvent(__state, num, num - __state, "silk.add." + ((object)(*(SilkAddSource*)(&source))/*cast due to .constrained prefix*/).ToString()));
			}
		}

		private static void TakeSilkPrefix(HeroController __instance, ref int __state)
		{
			__state = __instance.playerData?.silk ?? 0;
		}

		private unsafe static void TakeSilkPostfix(HeroController __instance, SilkTakeSource source, int __state)
		{
			GameEventPatches active = _active;
			int num = __instance.playerData?.silk ?? 0;
			if (active != null && num != __state)
			{
				active._events.Publish(new ResourceEvent(__state, num, num - __state, "silk.take." + ((object)(*(SilkTakeSource*)(&source))/*cast due to .constrained prefix*/).ToString()));
			}
		}

		private static void SendEquippedChangedEventPostfix()
		{
			GameEventPatches active = _active;
			if (active == null)
			{
				return;
			}
			active._events.PublishToolEquipsChanged();
			string text = HeroController.instance?.playerData?.CurrentCrestID;
			if (!string.IsNullOrEmpty(text))
			{
				string lastCrestId = _lastCrestId;
				_lastCrestId = text;
				if (lastCrestId == null)
				{
					active._events.Publish(new CrestChangedEvent("", text));
				}
				else if (!(lastCrestId == text))
				{
					active._events.Publish(new CrestChangedEvent(lastCrestId, text));
				}
			}
		}

		private static void SendDeathEventPostfix(HealthManager __instance)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Invalid comparison between Unknown and I4
			GameEventPatches active = _active;
			if (active == null)
			{
				return;
			}
			string enemyName;
			try
			{
				enemyName = (((Object)(object)((Component)__instance).gameObject != (Object)null) ? ((Object)((Component)__instance).gameObject).name : "unknown");
			}
			catch
			{
				enemyName = "unknown";
			}
			active._events.Publish(new EnemyKilledEvent(((Object)__instance).GetInstanceID(), enemyName));
			if (!(LastHitInstanceField != null))
			{
				return;
			}
			try
			{
				if (LastHitInstanceField.GetValue(__instance) is HitInstance val && val.IsHeroDamage && (int)val.AttackType == 2)
				{
					active._events.PublishSpellKilled();
				}
			}
			catch (Exception ex)
			{
				if (!_spellKillWarned)
				{
					_spellKillWarned = true;
					active._log.LogWarning((object)("[SpellKill] lastHitInstance read failed: " + ex.Message));
				}
			}
		}

		private static void SetOnBenchPostfix(bool onBench)
		{
			GameEventPatches active = _active;
			if (active == null)
			{
				_benchWasOnBench = onBench;
				return;
			}
			if (onBench && !_benchWasOnBench)
			{
				active._events.PublishBenchRested();
			}
			_benchWasOnBench = onBench;
		}

		private static void DiePrefix(bool nonLethal)
		{
			_active?._events.PublishPlayerDied();
		}

		private static void SceneInitPostfix()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			GameEventPatches active = _active;
			if (active != null)
			{
				GameEventHub events = active._events;
				Scene activeScene = SceneManager.GetActiveScene();
				events.PublishSceneChanged(((Scene)(ref activeScene)).name);
			}
		}

		private static void BindCompletedPostfix()
		{
			_active?._events.PublishBindCompleted();
		}
	}
	public static class HudIconCloneSanitizer
	{
		public enum ComponentDisposition
		{
			Keep,
			DisableThenDestroy,
			DestroyImmediate
		}

		public static ComponentDisposition Classify(Type type)
		{
			if (type == null)
			{
				return ComponentDisposition.DestroyImmediate;
			}
			if (typeof(RadialHudIcon).IsAssignableFrom(type))
			{
				return ComponentDisposition.DisableThenDestroy;
			}
			if (typeof(Animator).IsAssignableFrom(type))
			{
				return ComponentDisposition.DisableThenDestroy;
			}
			if (typeof(UnityMessageListener).IsAssignableFrom(type))
			{
				return ComponentDisposition.DisableThenDestroy;
			}
			if (typeof(RadialHudSwitchModeSettings).IsAssignableFrom(type))
			{
				return ComponentDisposition.DisableThenDestroy;
			}
			if (typeof(EventRegister).IsAssignableFrom(type))
			{
				return ComponentDisposition.DestroyImmediate;
			}
			if (typeof(EventResponder).IsAssignableFrom(type))
			{
				return ComponentDisposition.DestroyImmediate;
			}
			return ComponentDisposition.Keep;
		}

		public static bool IsArrowName(string? objectName)
		{
			if (objectName != null)
			{
				return objectName.IndexOf("Arrow", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		public static bool ShouldKeepRenderer(string? objectName, bool isCenterIcon, bool isArrow)
		{
			if (!(isCenterIcon || isArrow))
			{
				return IsArrowName(objectName);
			}
			return true;
		}

		public static bool ShouldKeepGraphic(string? objectName, bool isFill, bool isBg)
		{
			return isFill || isBg;
		}

		public static int Sanitize(GameObject root, string key, ManualLogSource? log, bool immediate = false)
		{
			if ((Object)(object)root == (Object)null)
			{
				return 0;
			}
			MonoBehaviour[] componentsInChildren = root.GetComponentsInChildren<MonoBehaviour>(true);
			if (componentsInChildren == null || componentsInChildren.Length == 0)
			{
				return 0;
			}
			Dictionary<Type, int> dictionary = new Dictionary<Type, int>();
			int num = 0;
			foreach (MonoBehaviour item in new List<MonoBehaviour>(componentsInChildren))
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				Type type = ((object)item).GetType();
				ComponentDisposition componentDisposition = Classify(type);
				if (componentDisposition == ComponentDisposition.Keep)
				{
					continue;
				}
				if (componentDisposition == ComponentDisposition.DestroyImmediate)
				{
					Object.DestroyImmediate((Object)(object)item);
				}
				else
				{
					Behaviour val = (Behaviour)(object)item;
					if (val != null)
					{
						val.enabled = false;
					}
					if (immediate)
					{
						Object.DestroyImmediate((Object)(object)item);
					}
					else
					{
						Object.Destroy((Object)(object)item);
					}
				}
				dictionary[type] = ((!dictionary.TryGetValue(type, out var value)) ? 1 : (value + 1));
				num++;
			}
			if (num > 0 && log != null)
			{
				foreach (KeyValuePair<Type, int> item2 in dictionary)
				{
					log.LogInfo((object)string.Format("[HudIconCloneSanitizer] '{0}' removed {1}x {2}{3}", key, item2.Value, item2.Key.FullName, immediate ? " (immediate)" : ""));
				}
			}
			return num;
		}
	}
	internal static class HudRootInstaller
	{
		private static StatusIconHostConfig? _config;

		private static StatusIconTextureService? _textures;

		private static ManualLogSource? _log;

		public static void Configure(StatusIconHostConfig config, StatusIconTextureService textures, ManualLogSource log)
		{
			_config = config;
			_textures = textures;
			_log = log;
		}

		public static void Postfix(BindOrbHudFrame __instance)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			if (_config == null || _textures == null)
			{
				return;
			}
			Transform val = ToolRowLocator.Resolve(_config.RowAnchorPath, ((Component)__instance).transform);
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).gameObject.AddComponent<HudStatusIconHost>().Configure(_config, ((Component)__instance).transform, _textures, _log, val);
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogInfo((object)("[HudStatusIconHost] attached to row container: " + BuildPath(val)));
				}
				return;
			}
			GameObject val2 = new GameObject("CrestsEvolveHUDRoot")
			{
				layer = 5
			};
			val2.transform.SetParent(((Component)__instance).transform, false);
			val2.transform.localScale = Vector3.one;
			val2.transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
			Vector3 localPosition = val2.transform.localPosition;
			localPosition.z = -0.0001f;
			val2.transform.localPosition = localPosition;
			val2.AddComponent<HudStatusIconHost>().Configure(_config, ((Component)__instance).transform, _textures, _log, null);
			ManualLogSource? log2 = _log;
			if (log2 != null)
			{
				log2.LogInfo((object)"[HudStatusIconHost] no row container found; created CrestsEvolveHUDRoot fallback under BindOrbHudFrame.");
			}
		}

		private static string BuildPath(Transform transform)
		{
			List<string> list = new List<string>();
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				list.Add(((Object)val).name);
				val = val.parent;
			}
			list.Reverse();
			return string.Join("/", list);
		}
	}
	public sealed class StatusIconHostConfig
	{
		public string RowAnchorPath { get; set; } = "auto";

		public Vector3 FallbackOffset { get; set; } = new Vector3(0f, -2.2f, 0f);

		public float Spacing { get; set; } = 1.1f;

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

		public static bool TryParseOffset(string text, out Vector3 offset)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			offset = Vector3.zero;
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			string[] array = text.Split(',');
			if (array.Length < 2 || !float.TryParse(array[0], out var result) || !float.TryParse(array[1], out var result2))
			{
				return false;
			}
			float result3;
			float num = ((array.Length > 2 && float.TryParse(array[2], out result3)) ? result3 : 0f);
			offset = new Vector3(result, result2, num);
			return true;
		}
	}
	public sealed class HudStatusIconHost : MonoBehaviour, IStatusIconPresenter
	{
		private sealed class NativeIconTemplate
		{
			public Transform Root;

			public string IconPath;

			public string FillPath;

			public string BgPath;

			public Color? InactiveColor { get; set; }
		}

		private sealed class IconView
		{
			private readonly Color _iconTint;

			private readonly string _key;

			private readonly StatusIconTextureService? _textures;

			private readonly Color? _nativeInactiveColor;

			private Text? _centerLabel;

			private static Font? _centerFont;

			public GameObject Root { get; }

			public SpriteRenderer Icon { get; }

			public Image RingFill { get; }

			public Image RingBg { get; }

			public Color RingColor { get; }

			public IconView(GameObject root, SpriteRenderer icon, Image ringFill, Image ringBg, Color ringColor, Color iconTint, string key, StatusIconTextureService? textures, Color? nativeInactiveColor = null)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				Root = root;
				Icon = icon;
				RingFill = ringFill;
				RingBg = ringBg;
				RingColor = ringColor;
				_iconTint = iconTint;
				_key = key;
				_textures = textures;
				_nativeInactiveColor = nativeInactiveColor;
			}

			public void Set(StatusIconState state)
			{
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_016c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0174: Unknown result type (might be due to invalid IL or missing references)
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
				Root.SetActive(state.Visible);
				if (!state.Visible)
				{
					return;
				}
				((Renderer)Icon).enabled = true;
				if (!((Component)Icon).gameObject.activeSelf)
				{
					((Component)Icon).gameObject.SetActive(true);
				}
				if (_textures != null && !string.IsNullOrEmpty(_key))
				{
					Sprite iconSprite = _textures.GetIconSprite(_key);
					if ((Object)(object)iconSprite != (Object)null)
					{
						Icon.sprite = iconSprite;
					}
					float iconScale = _textures.GetIconScale(_key);
					((Component)Icon).transform.localScale = new Vector3(iconScale, iconScale, 1f);
				}
				float num = ((state.Max <= 0) ? 1f : Mathf.Clamp01((float)state.Current / (float)state.Max));
				RingFill.fillAmount = num;
				RingBg.fillAmount = 1f - num;
				bool flag = state.Dimmed || state.Current <= 0;
				Icon.color = (Color)((!flag) ? _iconTint : (((??)_nativeInactiveColor) ?? Dim(_iconTint, 0.45f)));
				Color val2 = default(Color);
				Color val = ((state.ColorOverride != null && ColorUtility.TryParseHtmlString(state.ColorOverride, ref val2)) ? val2 : RingColor);
				((Graphic)RingFill).color = ((!flag) ? val : (_nativeInactiveColor.HasValue ? Multiply(val, _nativeInactiveColor.Value) : Dim(val, 0.45f)));
				((Graphic)RingBg).color = Dim(val, 0.3f);
				if (state.CenterText != null)
				{
					Text val3 = EnsureCenterText();
					if ((Object)(object)val3 != (Object)null)
					{
						val3.text = state.CenterText;
					}
				}
				else if ((Object)(object)_centerLabel != (Object)null)
				{
					((Component)_centerLabel).gameObject.SetActive(false);
				}
			}

			private Text? EnsureCenterText()
			{
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_centerLabel != (Object)null)
				{
					((Component)_centerLabel).gameObject.SetActive(true);
					return _centerLabel;
				}
				Font centerFont = GetCenterFont();
				if ((Object)(object)centerFont == (Object)null)
				{
					return null;
				}
				GameObject val = new GameObject("CenterText", new Type[3]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Text)
				})
				{
					layer = Root.layer
				};
				val.transform.SetParent(Root.transform, false);
				RectTransform component = val.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0.5f, 0.5f);
				component.anchorMax = new Vector2(0.5f, 0.5f);
				component.pivot = new Vector2(0.5f, 0.5f);
				component.sizeDelta = new Vector2(1.8f, 1f);
				((Transform)component).localPosition = Vector3.zero;
				Text component2 = val.GetComponent<Text>();
				component2.font = centerFont;
				component2.fontSize = 42;
				component2.alignment = (TextAnchor)4;
				((Graphic)component2).color = Color.white;
				((Graphic)component2).raycastTarget = false;
				component2.horizontalOverflow = (HorizontalWrapMode)1;
				component2.verticalOverflow = (VerticalWrapMode)1;
				_centerLabel = component2;
				return component2;
			}

			private static Font? GetCenterFont()
			{
				if ((Object)(object)_centerFont != (Object)null)
				{
					return _centerFont;
				}
				try
				{
					_centerFont = Resources.GetBuiltinResource<Font>("LegacyRuntime.ttf");
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)("[HudStatusIconHost] LegacyRuntime.ttf unavailable: " + ex.Message));
				}
				if ((Object)(object)_centerFont == (Object)null)
				{
					try
					{
						_centerFont = Resources.GetBuiltinResource<Font>("Arial.ttf");
					}
					catch (Exception ex2)
					{
						Debug.LogWarning((object)("[HudStatusIconHost] Arial.ttf unavailable; center text disabled. " + ex2.Message));
					}
				}
				return _centerFont;
			}
		}

		private StatusIconHostConfig _config = new StatusIconHostConfig();

		private Transform? _hudFrame;

		private Transform? _rowAnchor;

		private TransformLayoutGrid? _grid;

		private bool _gridManaged;

		private StatusIconTextureService? _textures;

		private ManualLogSource? _log;

		private readonly Dictionary<string, IconView> _icons = new Dictionary<string, IconView>(StringComparer.Ordinal);

		private HashSet<string> _visibleKeys = new HashSet<string>(StringComparer.Ordinal);

		private long _lastRevision = -1L;

		private Sprite? _nativeRingSprite;

		private readonly Dictionary<string, NativeIconTemplate> _nativeTemplates = new Dictionary<string, NativeIconTemplate>(StringComparer.Ordinal);

		private NativeIconTemplate? _defaultTemplate;

		private bool _rowProbeLogged;

		private bool _toolsAppeared;

		private static readonly HashSet<string> _nativeCloneHierarchyLogged = new HashSet<string>(StringComparer.Ordinal);

		public static HudStatusIconHost? Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			((EventBase)EventRegister.GetRegisterGuaranteed(((Component)this).gameObject, "TOOL EQUIPS CHANGED")).ReceivedEvent += RebuildLayout;
			((EventBase)EventRegister.GetRegisterGuaranteed(((Component)this).gameObject, "POST TOOL EQUIPS CHANGED")).ReceivedEvent += RebuildLayout;
			((EventBase)EventRegister.GetRegisterGuaranteed(((Component)this).gameObject, "TOOLS APPEAR")).ReceivedEvent += OnToolsAppear;
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		public void Configure(StatusIconHostConfig config, Transform hudFrame, StatusIconTextureService textures, ManualLogSource log, Transform? rowAnchor)
		{
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			_config = config ?? new StatusIconHostConfig();
			_hudFrame = hudFrame;
			_textures = textures;
			_log = log;
			if (_config.LogHierarchyProbe)
			{
				LogHierarchy(hudFrame, 0, 3);
				LogSiblingOverview(hudFrame.parent, "Bind Orb parent");
				Transform parent = hudFrame.parent;
				LogSiblingOverview((parent != null) ? parent.parent : null, "Bind Orb grandparent");
			}
			if ((Object)(object)rowAnchor != (Object)null)
			{
				AttachToRow(rowAnchor);
				LogRowStructure("hud-created");
				foreach (Transform item in rowAnchor)
				{
					Transform val = item;
					if ((Object)(object)((Component)val).GetComponent<ToolHudIcon>() != (Object)null && ((Component)val).gameObject.activeInHierarchy)
					{
						_toolsAppeared = true;
						break;
					}
				}
			}
			else
			{
				((Component)this).transform.localPosition = _config.FallbackOffset;
				ManualLogSource? log2 = _log;
				if (log2 != null)
				{
					log2.LogInfo((object)"[HudStatusIconHost][probe] no vanilla tool row detected; using fallback offset.");
				}
			}
			StatusIconProjector.Current?.Refresh();
		}

		public void Present(StatusIconProjection projection)
		{
			if (projection.Revision == _lastRevision || !_toolsAppeared)
			{
				return;
			}
			_lastRevision = projection.Revision;
			List<StatusIconState> list = projection.Icons.Where((StatusIconState state) => _textures == null || _textures.IsIconEnabled(state.Key)).ToList();
			HashSet<string> hashSet = new HashSet<string>(list.Select((StatusIconState i) => i.Key), StringComparer.Ordinal);
			foreach (string item in _icons.Keys.ToList())
			{
				if (!hashSet.Contains(item))
				{
					Object.Destroy((Object)(object)_icons[item].Root);
					_icons.Remove(item);
				}
			}
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			foreach (StatusIconState item2 in list)
			{
				IconView value2;
				if (item2.Visible)
				{
					hashSet2.Add(item2.Key);
					EnsureIcon(item2.Key);
					if (_icons.TryGetValue(item2.Key, out IconView value))
					{
						value.Set(item2);
					}
				}
				else if (_icons.TryGetValue(item2.Key, out value2))
				{
					Object.Destroy((Object)(object)value2.Root);
					_icons.Remove(item2.Key);
				}
			}
			if (!_visibleKeys.SetEquals(hashSet2))
			{
				_visibleKeys = hashSet2;
				RebuildLayout();
			}
		}

		public void Hide()
		{
			foreach (IconView value in _icons.Values)
			{
				Object.Destroy((Object)(object)value.Root);
			}
			_icons.Clear();
			_visibleKeys.Clear();
			_lastRevision = -1L;
		}

		private void OnToolsAppear()
		{
			_toolsAppeared = true;
			if (_nativeTemplates.Count == 0 && (Object)(object)_rowAnchor != (Object)null)
			{
				CaptureNativeRing(_rowAnchor);
			}
			StatusIconProjector.Current?.Refresh();
			RebuildLayout();
		}

		private void EnsureIcon(string key)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			if (!_icons.ContainsKey(key) && _textures != null && !TryCreateNativeIcon(key))
			{
				int layer = (((Object)(object)_hudFrame != (Object)null) ? ((Component)_hudFrame).gameObject.layer : 5);
				GameObject val = new GameObject("CE_Icon_" + key)
				{
					layer = layer
				};
				val.transform.SetParent(((Component)this).transform, false);
				val.transform.localScale = Vector3.one;
				GameObject val2 = new GameObject("Icon")
				{
					layer = layer
				};
				val2.transform.SetParent(val.transform, false);
				SpriteRenderer val3 = val2.AddComponent<SpriteRenderer>();
				val3.sprite = _textures.GetIconSprite(key);
				((Renderer)val3).sortingOrder = 10;
				float iconScale = _textures.GetIconScale(key);
				val2.transform.localScale = new Vector3(iconScale, iconScale, 1f);
				Image ringBg = CreateRingImage(val.transform, layer);
				Image ringFill = CreateRingImage(val.transform, layer);
				_icons[key] = new IconView(val, val3, ringFill, ringBg, _textures.GetRingColor(key), _textures.GetIconTint(key), key, _textures);
			}
		}

		private bool TryCreateNativeIcon(string key)
		{
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			NativeIconTemplate nativeIconTemplate = ResolveTemplate(key);
			if (nativeIconTemplate == null)
			{
				return false;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)nativeIconTemplate.Root).gameObject, ((Component)this).transform);
			((Object)val).name = "CE_Icon_" + key;
			val.SetActive(true);
			HudIconCloneSanitizer.Sanitize(val, key, _log, immediate: true);
			Transform obj = val.transform.Find(nativeIconTemplate.IconPath);
			SpriteRenderer val2 = ((obj != null) ? ((Component)obj).GetComponent<SpriteRenderer>() : null);
			Transform obj2 = val.transform.Find(nativeIconTemplate.FillPath);
			Image val3 = ((obj2 != null) ? ((Component)obj2).GetComponent<Image>() : null);
			Transform obj3 = val.transform.Find(nativeIconTemplate.BgPath);
			Image val4 = ((obj3 != null) ? ((Component)obj3).GetComponent<Image>() : null);
			if ((Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null)
			{
				Object.Destroy((Object)(object)val);
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogWarning((object)("[HudStatusIconHost] native icon clone failed for '" + key + "'; falling back to custom build."));
				}
				return false;
			}
			if ((Object)(object)val2 == (Object)null)
			{
				GameObject val5 = new GameObject("CE Center Icon")
				{
					layer = val.layer
				};
				val5.transform.SetParent(val.transform, false);
				val2 = val5.AddComponent<SpriteRenderer>();
				((Renderer)val2).sortingOrder = 10;
			}
			SanitizeNativeCloneContent(val, val2, val3, val4);
			LogNativeCloneHierarchy(key, val, val2);
			((Component)val2).gameObject.SetActive(true);
			((Renderer)val2).enabled = true;
			val2.sprite = _textures.GetIconSprite(key);
			float iconScale = _textures.GetIconScale(key);
			((Component)val2).transform.localScale = new Vector3(iconScale, iconScale, 1f);
			_icons[key] = new IconView(val, val2, val3, val4, _textures.GetRingColor(key), _textures.GetIconTint(key), key, _textures, nativeIconTemplate.InactiveColor);
			ManualLogSource? log2 = _log;
			if (log2 != null)
			{
				log2.LogInfo((object)("[HudStatusIconHost][probe] native icon cloned for '" + key + "' from " + BuildPath(nativeIconTemplate.Root)));
			}
			return true;
		}

		private static void SanitizeNativeCloneContent(GameObject cloneGo, SpriteRenderer icon, Image fill, Image bg)
		{
			Renderer[] componentsInChildren = cloneGo.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)icon))
				{
					SpriteRenderer val2 = (SpriteRenderer)(object)((val is SpriteRenderer) ? val : null);
					if (val2 == null || !HudIconCloneSanitizer.ShouldKeepRenderer(((Object)val2).name, isCenterIcon: false, isArrow: false))
					{
						val.enabled = false;
					}
				}
			}
			Graphic[] componentsInChildren2 = cloneGo.GetComponentsInChildren<Graphic>(true);
			foreach (Graphic val3 in componentsInChildren2)
			{
				if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val3 == (Object)(object)fill) && !((Object)(object)val3 == (Object)(object)bg))
				{
					((Behaviour)val3).enabled = false;
				}
			}
		}

		private void LogNativeCloneHierarchy(string key, GameObject cloneGo, SpriteRenderer icon)
		{
			if (_log != null && _nativeCloneHierarchyLogged.Add(key))
			{
				_log.LogInfo((object)("[HudStatusIconHost][probe] native clone hierarchy '" + key + "' (center=" + ((Object)((Component)icon).transform).name + "):"));
				LogCloneNode(cloneGo.transform, 1);
			}
		}

		private void LogCloneNode(Transform node, int depth)
		{
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Expected O, but got Unknown
			if ((Object)(object)node == (Object)null)
			{
				return;
			}
			List<string> list = new List<string>();
			Component[] components = ((Component)node).GetComponents<Component>();
			foreach (Component val in components)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				SpriteRenderer val2 = (SpriteRenderer)(object)((val is SpriteRenderer) ? val : null);
				if (val2 == null)
				{
					Image val3 = (Image)(object)((val is Image) ? val : null);
					if (val3 == null)
					{
						RawImage val4 = (RawImage)(object)((val is RawImage) ? val : null);
						if (val4 == null)
						{
							Text val5 = (Text)(object)((val is Text) ? val : null);
							if (val5 == null)
							{
								MeshRenderer val6 = (MeshRenderer)(object)((val is MeshRenderer) ? val : null);
								if (val6 != null)
								{
									list.Add($"MeshRenderer(enabled={((Renderer)val6).enabled})");
								}
								else
								{
									list.Add(((object)val).GetType().Name);
								}
							}
							else
							{
								list.Add($"Text(enabled={((Behaviour)val5).enabled})");
							}
						}
						else
						{
							object arg = ((Behaviour)val4).enabled;
							Texture texture = val4.texture;
							list.Add(string.Format("RawImage(enabled={0},tex={1})", arg, ((texture != null) ? ((Object)texture).name : null) ?? "null"));
						}
					}
					else
					{
						object arg2 = ((Behaviour)val3).enabled;
						Sprite sprite = val3.sprite;
						list.Add(string.Format("Image(enabled={0},sprite={1})", arg2, ((sprite != null) ? ((Object)sprite).name : null) ?? "null"));
					}
				}
				else
				{
					object arg3 = ((Renderer)val2).enabled;
					Sprite sprite2 = val2.sprite;
					list.Add(string.Format("SpriteRenderer(enabled={0},sprite={1})", arg3, ((sprite2 != null) ? ((Object)sprite2).name : null) ?? "null"));
				}
			}
			ManualLogSource? log = _log;
			if (log != null)
			{
				log.LogInfo((object)("[HudStatusIconHost][probe]   " + new string(' ', (depth - 1) * 2) + ((Object)node).name + " " + string.Format("active={0} [{1}]", ((Component)node).gameObject.activeSelf, string.Join(",", list))));
			}
			foreach (Transform item in node)
			{
				Transform node2 = item;
				LogCloneNode(node2, depth + 1);
			}
		}

		private Image CreateRingImage(Transform parent, int layer)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			GameObject val = new GameObject("Ring", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			})
			{
				layer = layer
			};
			val.transform.SetParent(parent, false);
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(1f, 1f);
			Image component = val.GetComponent<Image>();
			component.sprite = _nativeRingSprite ?? _textures.RingSprite;
			component.type = (Type)3;
			component.fillMethod = (FillMethod)4;
			component.fillOrigin = 2;
			((Graphic)component).raycastTarget = false;
			return component;
		}

		private void RebuildLayout()
		{
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			if (_icons.Count == 0)
			{
				return;
			}
			if (_gridManaged)
			{
				TransformLayoutGrid? grid = _grid;
				if (grid != null)
				{
					((TransformLayout)grid).UpdatePositions();
				}
				LogRowStructureCompact(null);
				return;
			}
			List<float> list = new List<float>();
			float? referenceY = null;
			if ((Object)(object)_rowAnchor != (Object)null)
			{
				foreach (Transform item in _rowAnchor)
				{
					Transform val = item;
					if (!((Object)(object)val == (Object)(object)((Component)this).transform) && !val.IsChildOf(((Component)this).transform) && ((Component)val).gameObject.activeInHierarchy && (!((Object)(object)((Component)val).GetComponent<ToolHudIcon>() == (Object)null) || !((Object)(object)((Component)val).GetComponent<Image>() == (Object)null) || !((Object)(object)((Component)val).GetComponent<SpriteRenderer>() == (Object)null)))
					{
						list.Add(val.localPosition.x);
						if (!referenceY.HasValue && (Object)(object)((Component)val).GetComponent<ToolHudIcon>() != (Object)null)
						{
							referenceY = val.localPosition.y;
						}
					}
				}
			}
			ToolRowLayout toolRowLayout = ToolRowLayoutCalculator.Calculate(list, referenceY, _config.Spacing, _config.FallbackOffset.x);
			int num = 0;
			foreach (IconView value in _icons.Values)
			{
				value.Root.transform.localPosition = new Vector3(toolRowLayout.StartX + (float)num * toolRowLayout.Spacing, toolRowLayout.RowY, 0f);
				num++;
			}
			LogRowStructureCompact(toolRowLayout);
		}

		private void AttachToRow(Transform anchor)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			_rowAnchor = anchor;
			_grid = ((Component)anchor).GetComponent<TransformLayoutGrid>();
			_gridManaged = (Object)(object)_grid != (Object)null;
			if ((Object)(object)anchor != (Object)(object)((Component)this).transform)
			{
				((Component)this).transform.SetParent(anchor, false);
				((Component)this).transform.localPosition = Vector3.zero;
			}
			ManualLogSource? log = _log;
			if (log != null)
			{
				log.LogInfo((object)$"[HudStatusIconHost][probe] row anchor: {BuildPath(anchor)} gridManaged={_gridManaged}");
			}
			CaptureNativeRing(anchor);
		}

		private void CaptureNativeRing(Transform anchor)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)anchor == (Object)null)
			{
				return;
			}
			foreach (Transform item in anchor)
			{
				Transform val = item;
				ToolHudIcon component = ((Component)val).GetComponent<ToolHudIcon>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				string text = ResolveTemplateKey(val, component);
				if (text == null || _nativeTemplates.ContainsKey(text))
				{
					continue;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(RadialHudIcon), "icon");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(RadialHudIcon), "radialImage");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(RadialHudIcon), "radialImageBg");
				FieldInfo fieldInfo4 = AccessTools.Field(typeof(RadialHudIcon), "inactiveColor");
				object? obj = fieldInfo?.GetValue(component);
				SpriteRenderer val2 = (SpriteRenderer)((obj is SpriteRenderer) ? obj : null);
				if (val2 == null)
				{
					continue;
				}
				object? obj2 = fieldInfo2?.GetValue(component);
				Image val3 = (Image)((obj2 is Image) ? obj2 : null);
				if (val3 == null)
				{
					continue;
				}
				object? obj3 = fieldInfo3?.GetValue(component);
				Image val4 = (Image)((obj3 is Image) ? obj3 : null);
				if (val4 != null)
				{
					Color? inactiveColor = ((fieldInfo4?.GetValue(component) is Color value) ? new Color?(value) : ((Color?)null));
					if ((Object)(object)_nativeRingSprite == (Object)null && (Object)(object)val3.sprite != (Object)null)
					{
						_nativeRingSprite = val3.sprite;
					}
					GameObject val5 = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)this).transform);
					((Object)val5).name = "CE_OwnedTemplate_" + text;
					val5.SetActive(false);
					HudIconCloneSanitizer.Sanitize(val5, "<template>", _log);
					NativeIconTemplate nativeIconTemplate = new NativeIconTemplate
					{
						Root = val5.transform,
						IconPath = GetRelativePath(val, ((Component)val2).transform),
						FillPath = GetRelativePath(val, ((Component)val3).transform),
						BgPath = GetRelativePath(val, ((Component)val4).transform),
						InactiveColor = inactiveColor
					};
					_nativeTemplates[text] = nativeIconTemplate;
					if (_defaultTemplate == null || text == "N")
					{
						_defaultTemplate = nativeIconTemplate;
					}
					ManualLogSource? log = _log;
					if (log != null)
					{
						log.LogInfo((object)("[HudStatusIconHost][probe] owned icon template captured (" + text + ") from " + BuildPath(val)));
					}
				}
			}
			if (_defaultTemplate == null && _nativeTemplates.Count > 0)
			{
				_defaultTemplate = _nativeTemplates.Values.First();
			}
		}

		private static string? ResolveTemplateKey(Transform child, ToolHudIcon toolHudIcon)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Invalid comparison between Unknown and I4
			string name = ((Object)child).name;
			if (name.EndsWith("U", StringComparison.Ordinal) || name.IndexOf(" Up", StringComparison.Ordinal) >= 0)
			{
				return "U";
			}
			if (name.EndsWith("D", StringComparison.Ordinal) || name.IndexOf(" Down", StringComparison.Ordinal) >= 0)
			{
				return "D";
			}
			if (name.EndsWith("N", StringComparison.Ordinal) || name.IndexOf(" Neutral", StringComparison.Ordinal) >= 0)
			{
				return "N";
			}
			if (AccessTools.Field(typeof(ToolHudIcon), "binding")?.GetValue(toolHudIcon) is AttackToolBinding val)
			{
				if ((int)val != 1)
				{
					if ((int)val == 2)
					{
						return "D";
					}
					return "N";
				}
				return "U";
			}
			return null;
		}

		private NativeIconTemplate? ResolveTemplate(string key)
		{
			if (key.EndsWith(".up", StringComparison.OrdinalIgnoreCase) && _nativeTemplates.TryGetValue("U", out NativeIconTemplate value))
			{
				return value;
			}
			if (key.EndsWith(".down", StringComparison.OrdinalIgnoreCase) && _nativeTemplates.TryGetValue("D", out NativeIconTemplate value2))
			{
				return value2;
			}
			if (key.EndsWith(".neutral", StringComparison.OrdinalIgnoreCase) && _nativeTemplates.TryGetValue("N", out NativeIconTemplate value3))
			{
				return value3;
			}
			return _defaultTemplate;
		}

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

		private void LogHierarchy(Transform parent, int depth, int maxDepth)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if ((Object)(object)parent == (Object)null || depth > maxDepth)
			{
				return;
			}
			foreach (Transform item in parent)
			{
				Transform val = item;
				string arg = string.Join(",", from c in ((Component)val).GetComponents<Component>()
					select ((object)c).GetType().Name);
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogInfo((object)$"[HudStatusIconHost][probe] {BuildPath(val)} layer={((Component)val).gameObject.layer} [{arg}]");
				}
				LogHierarchy(val, depth + 1, maxDepth);
			}
		}

		private void LogSiblingOverview(Transform? parent, string label)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			if ((Object)(object)parent == (Object)null)
			{
				return;
			}
			ManualLogSource? log = _log;
			if (log != null)
			{
				log.LogInfo((object)("[HudStatusIconHost][probe] " + label + " sibling overview:"));
			}
			foreach (Transform item in parent)
			{
				Transform val = item;
				ManualLogSource? log2 = _log;
				if (log2 != null)
				{
					log2.LogInfo((object)$"[HudStatusIconHost][probe]   {((Object)val).name} layer={((Component)val).gameObject.layer}");
				}
			}
		}

		private void LogRowStructure(string reason)
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			if ((Object)(object)_rowAnchor == (Object)null || _log == null || !_config.LogHierarchyProbe)
			{
				return;
			}
			string text = string.Join(",", from c in ((Component)_rowAnchor).GetComponents<Component>()
				select ((object)c).GetType().Name);
			_log.LogInfo((object)("[HudStatusIconHost][probe] row structure (" + reason + ") anchor=" + BuildPath(_rowAnchor) + " [" + text + "]"));
			foreach (Transform item in _rowAnchor)
			{
				Transform val = item;
				string text2 = string.Join(",", from c in ((Component)val).GetComponents<Component>()
					select ((object)c).GetType().Name);
				_log.LogInfo((object)($"[HudStatusIconHost][probe]   {((Object)val).name} layer={((Component)val).gameObject.layer} " + $"active={((Component)val).gameObject.activeSelf} pos={val.localPosition} scale={val.localScale} [{text2}]"));
			}
			Transform parent = _rowAnchor.parent;
			if (!((Object)(object)parent != (Object)null))
			{
				return;
			}
			string text3 = string.Join(",", from c in ((Component)parent).GetComponents<Component>()
				select ((object)c).GetType().Name);
			_log.LogInfo((object)("[HudStatusIconHost][probe] row parent '" + ((Object)parent).name + "' [" + text3 + "] siblings:"));
			foreach (Transform item2 in parent)
			{
				Transform val2 = item2;
				string arg = string.Join(",", from c in ((Component)val2).GetComponents<Component>()
					select ((object)c).GetType().Name);
				_log.LogInfo((object)$"[HudStatusIconHost][probe]   {((Object)val2).name} layer={((Component)val2).gameObject.layer} [{arg}]");
			}
		}

		private void LogRowStructureCompact(ToolRowLayout? layout)
		{
			if (!((Object)(object)_rowAnchor == (Object)null) && _log != null && _config.LogHierarchyProbe && !_rowProbeLogged)
			{
				_rowProbeLogged = true;
				string text = string.Join("; ", from Transform c in (IEnumerable)_rowAnchor
					where (Object)(object)c != (Object)(object)((Component)this).transform
					select $"{((Object)c).name}(active={((Component)c).gameObject.activeSelf},x={c.localPosition.x:F2})");
				string text2 = ((layout == null) ? "grid-managed" : $"startX={layout.StartX:F2} y={layout.RowY:F2} spacing={layout.Spacing:F2}");
				_log.LogInfo((object)("[HudStatusIconHost][probe] row relayout " + text2 + " children=[" + text + "]"));
			}
		}

		private static string BuildPath(Transform transform)
		{
			List<string> list = new List<string>();
			Transform val = transform;
			while ((Object)(object)val != (Object)null)
			{
				list.Add(((Object)val).name);
				val = val.parent;
			}
			list.Reverse();
			return string.Join("/", list);
		}

		private static Color Dim(Color color, float factor)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			return new Color(color.r * factor, color.g * factor, color.b * factor, color.a);
		}

		private static Color Multiply(Color a, Color b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			return new Color(a.r * b.r, a.g * b.g, a.b * b.b, a.a * b.a);
		}
	}
	public sealed class HunterStateAccessor
	{
		private readonly ManualLogSource _log;

		private readonly FieldInfo? _hunterStateField;

		private int? _savedMeterHits;

		private bool _forceActive;

		private bool _warned;

		public bool IsReady => _hunterStateField != null;

		public HunterStateAccessor(ManualLogSource log)
		{
			_log = log;
			_hunterStateField = AccessTools.Field(typeof(HeroController), "hunterUpgState");
			if (_hunterStateField == null)
			{
				_log.LogWarning((object)"[HunterState] hunterUpgState field not found; rage focus forcing disabled.");
			}
		}

		public int CurrentMeterHits()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (_hunterStateField == null)
			{
				return 0;
			}
			HeroController instance = HeroController.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return 0;
			}
			try
			{
				return ((HunterUpgCrestStateInfo)_hunterStateField.GetValue(instance)).CurrentMeterHits;
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
				return 0;
			}
		}

		public void SetFocusActive(bool active, int forcedMeterHits)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (_hunterStateField == null || forcedMeterHits <= 0)
			{
				return;
			}
			HeroController instance = HeroController.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			try
			{
				HunterUpgCrestStateInfo val = (HunterUpgCrestStateInfo)_hunterStateField.GetValue(instance);
				if (active)
				{
					if (!_forceActive)
					{
						_savedMeterHits = val.CurrentMeterHits;
						_forceActive = true;
					}
					val.CurrentMeterHits = forcedMeterHits;
				}
				else
				{
					if (!_forceActive)
					{
						return;
					}
					val.CurrentMeterHits = _savedMeterHits.GetValueOrDefault();
					_forceActive = false;
					_savedMeterHits = null;
				}
				_hunterStateField.SetValue(instance, val);
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
			}
		}

		private void WarnOnce(Exception ex)
		{
			if (!_warned)
			{
				_warned = true;
				_log.LogWarning((object)("[HunterState] access failed (" + ex.GetType().Name + ": " + ex.Message + "); suppressing further warnings."));
			}
		}
	}
	public interface IGameApi : IDisposable
	{
		string CurrentCrestId { get; }

		int CurrentSilk { get; }

		int CurrentHealth { get; }

		int MaxHealth { get; }

		bool TryHeal(int amount, string reason);

		bool TrySpendSilk(int amount, string reason);

		void AddSilk(int amount, string reason);

		void AddShards(int amount, string reason);

		void SetTemporaryCharmLevelOffset(int offset, string source);

		void SetTemporaryMaxHealth(int? maxHealth);

		void ClearBlueHealth(string reason);

		IDisposable AcquireInvulnerability(string source, double maxDurationSeconds);

		bool TryInvokeVanillaAction(string bindingId);

		void SpawnAdditionalDamage(AdditionalDamageCommand command);

		bool SpawnPlayerExplosion(double damage, string sourceTag, float radius);

		bool SpawnPlayerExplosionAt(double damage, string sourceTag, float radius, Vector3 position);

		bool SpawnNativeExplosion();

		bool SpawnNativeExplosionAt(Vector3 position);

		bool TryGetToolColor(string toolId, out ToolColorKind color);
	}
	public static class MaxHealthHudSync
	{
		private static ManualLogSource? _log;

		private static bool _warned;

		public static void Configure(ManualLogSource log)
		{
			_log = log;
			_warned = false;
		}

		public static void Apply(int? projectedMax)
		{
			try
			{
				Transform val = FindHealthRoot();
				if ((Object)(object)val == (Object)null)
				{
					WarnOnce("[MaxHealthHudSync] 'Hud Canvas/Health' not found; mask sync skipped (HEALTH UPDATE fallback still sent).");
					return;
				}
				PlayMakerFSM[] componentsInChildren = ((Component)val).GetComponentsInChildren<PlayMakerFSM>(true);
				foreach (PlayMakerFSM val2 in componentsInChildren)
				{
					if ((Object)(object)val2 == (Object)null || !string.Equals(val2.FsmName, "health_display", StringComparison.OrdinalIgnoreCase))
					{
						continue;
					}
					FsmVariables fsmVariables = val2.FsmVariables;
					FsmInt val3 = ((fsmVariables != null) ? fsmVariables.FindFsmInt("Health Number") : null);
					if (val3 != null && val3.Value > 1)
					{
						bool flag = !projectedMax.HasValue || val3.Value <= projectedMax.Value;
						GameObject gameObject = ((Component)val2).gameObject;
						if (!((Object)(object)gameObject == (Object)null) && gameObject.activeSelf != flag)
						{
							gameObject.SetActive(flag);
						}
					}
				}
			}
			catch (Exception ex)
			{
				WarnOnce("[MaxHealthHudSync] Apply failed: " + ex.Message);
			}
		}

		private static Transform? FindHealthRoot()
		{
			GameObject val = GameObject.Find("Hud Canvas");
			if ((Object)(object)val != (Object)null)
			{
				Transform val2 = val.transform.Find("Health");
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			GameObject obj = GameObject.Find("Hud Canvas/Health");
			if (obj == null)
			{
				return null;
			}
			return obj.transform;
		}

		private static void WarnOnce(string message)
		{
			if (!_warned)
			{
				_warned = true;
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogWarning((object)message);
				}
			}
		}
	}
	public sealed class NeedleforgeAdapter : IDisposable
	{
		public const string PluginGuid = "io.github.needleforge";

		private readonly ManualLogSource _log;

		public bool IsAvailable { get; private set; }

		public string? InstalledVersion { get; private set; }

		public ColorData? WhiteColorData { get; private set; }

		public NeedleforgeAdapter(ManualLogSource log)
		{
			_log = log;
		}

		public void Initialize()
		{
			foreach (PluginInfo value in Chainloader.PluginInfos.Values)
			{
				if (!(value.Metadata.GUID != "io.github.needleforge"))
				{
					IsAvailable = true;
					InstalledVersion = value.Metadata.Version.ToString();
					_log.LogInfo((object)("Needleforge adapter bound: version=" + InstalledVersion));
					return;
				}
			}
			_log.LogWarning((object)"Needleforge (io.github.needleforge) not found; custom crest/tool registration is disabled.");
		}

		public bool TryAddCrest(string name)
		{
			if (!IsAvailable || string.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			try
			{
				NeedleforgePlugin.AddCrest(name);
				_log.LogInfo((object)("Needleforge crest registered: " + name));
				return true;
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"Needleforge AddCrest failed for '{name}': {arg}");
				return false;
			}
		}

		public bool TryAddTool(string name, ToolItemType type)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!IsAvailable || string.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			try
			{
				NeedleforgePlugin.AddTool(name, type);
				_log.LogInfo((object)$"Needleforge tool registered: {name} ({type})");
				return true;
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"Needleforge AddTool failed for '{name}': {arg}");
				return false;
			}
		}

		public bool TryAddToolColor(string name, Color color, bool isAttackType = false)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!IsAvailable || string.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			try
			{
				NeedleforgePlugin.AddToolColor(name, color, isAttackType);
				_log.LogInfo((object)("Needleforge tool color registered: " + name));
				return true;
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"Needleforge AddToolColor failed for '{name}': {arg}");
				return false;
			}
		}

		public bool TryAddWhiteToolColor(out ToolItemType type)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected I4, but got Unknown
			type = (ToolItemType)2;
			if (!IsAvailable)
			{
				return false;
			}
			try
			{
				ColorData val = NeedleforgePlugin.AddToolColor("White", Color.white, false);
				type = (ToolItemType)(int)val.Type;
				WhiteColorData = val;
				val.AddValidTypes((ToolItemType[])(object)new ToolItemType[2]
				{
					(ToolItemType)1,
					(ToolItemType)2
				});
				_log.LogInfo((object)$"Needleforge white tool color registered: type={type}");
				return true;
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"Needleforge AddToolColor(White) failed: {arg}");
				return false;
			}
		}

		public bool TrySetWhiteToolHeader(Sprite sprite)
		{
			if (!IsAvailable || WhiteColorData == null || (Object)(object)sprite == (Object)null)
			{
				return false;
			}
			try
			{
				WhiteColorData.header = sprite;
				_log.LogInfo((object)"Needleforge white tool section header set.");
				return true;
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"Needleforge white tool header failed: {arg}");
				return false;
			}
		}

		public ToolData? GetToolDataByName(string name)
		{
			if (!IsAvailable)
			{
				return null;
			}
			return NeedleforgePlugin.GetToolDataByName(name);
		}

		public void Dispose()
		{
		}
	}
	public sealed class PimpiloExplosionSpawner
	{
		public const string PrefabName = "Tool_pinpilo_explosion";

		private readonly ManualLogSource _log;

		private GameObject? _prefab;

		private bool _warnedResolve;

		private bool _warnedSpawn;

		public PimpiloExplosionSpawner(ManualLogSource log)
		{
			_log = log ?? throw new ArgumentNullException("log");
		}

		public bool Spawn(Vector3 position)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = ResolvePrefab();
			if ((Object)(object)val == (Object)null)
			{
				if (!_warnedResolve)
				{
					_warnedResolve = true;
					_log.LogWarning((object)"[PimpiloExplosion] Tool_pinpilo_explosion prefab not resolved; shared native explosion disabled.");
				}
				return false;
			}
			try
			{
				GameObject val2 = ObjectPoolExtensions.Spawn(val, position, Quaternion.identity);
				if ((Object)(object)val2 == (Object)null)
				{
					return false;
				}
				val2.SetActive(true);
				return true;
			}
			catch (Exception ex)
			{
				if (!_warnedSpawn)
				{
					_warnedSpawn = true;
					_log.LogWarning((object)("[PimpiloExplosion] spawn failed: " + ex.Message));
				}
				return false;
			}
		}

		private GameObject? ResolvePrefab()
		{
			if ((Object)(object)_prefab != (Object)null)
			{
				return _prefab;
			}
			_prefab = LoadViaAddressables();
			if ((Object)(object)_prefab == (Object)null)
			{
				_prefab = FindUniqueRuntimeObject();
			}
			if ((Object)(object)_prefab != (Object)null)
			{
				_log.LogInfo((object)("[PimpiloExplosion] prefab resolved: " + ((Object)_prefab).name));
			}
			return _prefab;
		}

		private GameObject? LoadViaAddressables()
		{
			try
			{
				object? obj = LoadAddressableObject(typeof(GameObject), "Tool_pinpilo_explosion");
				return (GameObject?)((obj is GameObject) ? obj : null);
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[PimpiloExplosion] Addressables load failed for 'Tool_pinpilo_explosion': " + ex.Message));
				return null;
			}
		}

		private object? LoadAddressableObject(Type assetType, string key)
		{
			try
			{
				Type type = (from a in AppDomain.CurrentDomain.GetAssemblies()
					select a.GetType("UnityEngine.AddressableAssets.Addressables", throwOnError: false)).FirstOrDefault((Type t) => t != null);
				if (type == null)
				{
					return null;
				}
				MethodInfo[] array = (from m in type.GetMethods(BindingFlags.Static | BindingFlags.Public)
					where m.Name == "LoadAssetAsync" && m.IsGenericMethodDefinition && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == typeof(string)
					select m).Take(2).ToArray();
				if (array.Length != 1)
				{
					return null;
				}
				object obj = array[0].MakeGenericMethod(assetType).Invoke(null, new object[1] { key });
				if (obj == null)
				{
					return null;
				}
				MethodInfo method = obj.GetType().GetMethod("WaitForCompletion", Type.EmptyTypes);
				if (method == null)
				{
					return null;
				}
				return method.Invoke(obj, null);
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[PimpiloExplosion] Addressables load failed for '" + key + "': " + ex.Message));
				return null;
			}
		}

		private GameObject? FindUniqueRuntimeObject()
		{
			try
			{
				return ((IEnumerable<GameObject>)Resources.FindObjectsOfTypeAll<GameObject>()).FirstOrDefault((Func<GameObject, bool>)((GameObject go) => (Object)(object)go != (Object)null && ((Object)go).name == "Tool_pinpilo_explosion"));
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[PimpiloExplosion] runtime object search failed: " + ex.Message));
				return null;
			}
		}
	}
	public sealed class PlayerExplosionSpawner
	{
		private readonly ManualLogSource _log;

		private readonly MethodInfo? _hit;

		private bool _warned;

		public PlayerExplosionSpawner(ManualLogSource log, DynamicPatchResolver resolver)
		{
			_log = log;
			_hit = resolver.Resolve("player.explosion.apply") as MethodInfo;
			if (_hit == null)
			{
				_log.LogWarning((object)"[Explosion] HealthManager.Hit(HitInstance) unresolved; explosions are log-only.");
			}
		}

		public bool Spawn(double damage, float radius)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			HeroController instance = HeroController.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			return SpawnAt(damage, radius, ((Component)instance).transform.position);
		}

		public bool SpawnAt(double damage, float radius, Vector3 position)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			if (_hit == null || damage <= 0.0)
			{
				return false;
			}
			try
			{
				HeroController instance = HeroController.instance;
				if ((Object)(object)instance == (Object)null)
				{
					return false;
				}
				Collider2D[] array = Physics2D.OverlapCircleAll(new Vector2(position.x, position.y), radius);
				bool result = false;
				Collider2D[] array2 = array;
				foreach (Collider2D val in array2)
				{
					if (!((Object)(object)val == (Object)null))
					{
						HealthManager componentInParent = ((Component)val).GetComponentInParent<HealthManager>();
						if (!((Object)(object)componentInParent == (Object)null) && !((Object)(object)((Component)componentInParent).gameObject == (Object)(object)((Component)instance).gameObject))
						{
							HitInstance val2 = new HitInstance
							{
								Source = ((Component)instance).gameObject,
								AttackType = (AttackTypes)11,
								DamageDealt = (int)Math.Round(damage),
								IsHeroDamage = true,
								IsFirstHit = true,
								DamageScalingLevel = 1,
								MagnitudeMultiplier = 1f,
								Multiplier = 1f
							};
							_hit.Invoke(componentInParent, new object[1] { val2 });
							result = true;
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
				return false;
			}
		}

		private void WarnOnce(Exception ex)
		{
			if (!_warned)
			{
				_warned = true;
				_log.LogWarning((object)("[Explosion] spawn failed (" + ex.GetType().Name + ": " + ex.Message + "); suppressing further warnings."));
			}
		}
	}
	public static class ReaperRuneBridge
	{
		public static Func<bool> IsDropRateOverrideActive { get; set; } = () => false;

		public static Func<bool> IsAutoCollectEnabled { get; set; } = () => false;

		public static Func<int> SubBladeChargedAttacksRemaining { get; set; } = () => 0;

		public static Func<bool> IsHailOfBladesFullLayers { get; set; } = () => false;

		public static Func<bool> IsChargeSlashEnhanced { get; set; } = () => false;

		public static bool IsDropRateWindowActive()
		{
			return IsDropRateOverrideActive();
		}

		public static bool IsSubBladeCharged()
		{
			return SubBladeChargedAttacksRemaining() > 0;
		}
	}
	public sealed class ReaperStateAccessor
	{
		private readonly ManualLogSource _log;

		private readonly MethodInfo? _stateGetter;

		private readonly PropertyInfo? _modeProperty;

		private readonly FieldInfo? _modeField;

		private readonly PropertyInfo? _durationProperty;

		private readonly FieldInfo? _durationField;

		private readonly FieldInfo? _stateField;

		private bool _rageForced;

		private bool _disabled;

		private bool _warned;

		private float _extraDuration;

		public ReaperStateAccessor(ManualLogSource log, DynamicPatchResolver resolver)
		{
			_log = log;
			_stateGetter = resolver.Resolve("player.reaper.state.mode") as MethodInfo;
			_stateField = AccessTools.Field(typeof(HeroController), "reaperState");
			if (_stateGetter == null)
			{
				_disabled = true;
				_log.LogWarning((object)"[ReaperState] binding 'player.reaper.state.mode' unresolved; strong icon disabled.");
				return;
			}
			Type returnType = _stateGetter.ReturnType;
			_modeProperty = AccessTools.Property(returnType, "IsInReaperMode");
			_modeField = ((_modeProperty == null) ? AccessTools.Field(returnType, "IsInReaperMode") : null);
			_durationProperty = AccessTools.Property(returnType, "ReaperModeDurationLeft");
			_durationField = ((_durationProperty == null) ? AccessTools.Field(returnType, "ReaperModeDurationLeft") : null);
			if (_modeProperty == null && _modeField == null)
			{
				_disabled = true;
				_log.LogWarning((object)("[ReaperState] member 'IsInReaperMode' not found on " + returnType.FullName + "; strong icon disabled."));
			}
			else if (_durationProperty == null && _durationField == null)
			{
				_disabled = true;
				_log.LogWarning((object)("[ReaperState] member 'ReaperModeDurationLeft' not found on " + returnType.FullName + "; countdown disabled."));
			}
			else
			{
				_disabled = false;
				_log.LogInfo((object)("[ReaperState] accessor ready: " + returnType.FullName + "."));
			}
		}

		public bool IsInReaperMode()
		{
			if (_disabled || _stateGetter == null)
			{
				return false;
			}
			object state = GetState();
			if (state == null)
			{
				return false;
			}
			try
			{
				return Convert.ToBoolean(GetValue(_modeProperty, _modeField, state));
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
				return false;
			}
		}

		public float SecondsLeft()
		{
			if (_disabled || _stateGetter == null)
			{
				return 0f;
			}
			object state = GetState();
			if (state == null)
			{
				return 0f;
			}
			try
			{
				return Convert.ToSingle(GetValue(_durationProperty, _durationField, state));
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
				return 0f;
			}
		}

		public void AddReaperModeDuration(float seconds)
		{
			if (_disabled || seconds <= 0f)
			{
				return;
			}
			_extraDuration += seconds;
			WriteState(delegate(ReaperCrestStateInfo state)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				if (state.IsInReaperMode)
				{
					state.ReaperModeDurationLeft = Math.Max(0f, state.ReaperModeDurationLeft) + seconds;
				}
			});
			_log.LogDebug((object)$"[ReaperState] extra duration += {seconds} (total extra {_extraDuration}).");
		}

		public void ResetExtraDuration()
		{
			if (_extraDuration != 0f)
			{
				_extraDuration = 0f;
				_log.LogDebug((object)"[ReaperState] extra duration reset.");
			}
		}

		public void SetRageModeActive(bool active)
		{
			if (active)
			{
				_rageForced = true;
				WriteState(delegate(ReaperCrestStateInfo state)
				{
					state.IsInReaperMode = true;
					state.ReaperModeDurationLeft = Gameplay.ReaperModeDuration + _extraDuration;
				});
			}
			else
			{
				_rageForced = false;
			}
		}

		public void RefreshRageDuration()
		{
			if (_rageForced)
			{
				WriteState(delegate(ReaperCrestStateInfo state)
				{
					state.ReaperModeDurationLeft = Gameplay.ReaperModeDuration + _extraDuration;
				});
			}
		}

		private void WriteState(Action<ReaperCrestStateInfo> change)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (_stateField == null)
			{
				return;
			}
			HeroController instance = HeroController.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			try
			{
				ReaperCrestStateInfo val = (ReaperCrestStateInfo)_stateField.GetValue(instance);
				change(val);
				_stateField.SetValue(instance, val);
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
			}
		}

		private object? GetState()
		{
			try
			{
				HeroController instance = HeroController.instance;
				if ((Object)(object)instance == (Object)null)
				{
					return null;
				}
				return _stateGetter.Invoke(instance, null);
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
				return null;
			}
		}

		private static object? GetValue(PropertyInfo? property, FieldInfo? field, object instance)
		{
			if (!(property != null))
			{
				return field.GetValue(instance);
			}
			return property.GetValue(instance, null);
		}

		private void WarnOnce(Exception ex)
		{
			if (!_warned)
			{
				_warned = true;
				_log.LogWarning((object)("[ReaperState] access failed (" + ex.GetType().Name + ": " + ex.Message + "); suppressing further warnings."));
			}
		}
	}
	public sealed class ReflectionGameApi : IGameApi, IDisposable
	{
		private sealed class NoopDisposable : IDisposable
		{
			public void Dispose()
			{
			}
		}

		private readonly ManualLogSource _log;

		private readonly GameEventHub _events;

		private readonly DynamicPatchResolver _resolver;

		private readonly InvulnerabilityLeaseService _leases;

		private readonly FieldInfo? _healthField;

		private readonly FieldInfo? _maxHealthField;

		private readonly PlayerExplosionSpawner? _explosions;

		private readonly PimpiloExplosionSpawner? _nativeExplosions;

		private int _trackedHealth;

		private int _trackedMaxHealth = 1;

		private int _lastPublishedHealth = -1;

		private int _lastPublishedMaxHealth = -1;

		private int? _originalMaxHealthBase;

		private int? _originalHealth;

		private bool _maxHealthProjected;

		public string CurrentCrestId => HeroController.instance?.playerData?.CurrentCrestID ?? "unbound";

		public int CurrentSilk => (HeroController.instance?.playerData?.silk).GetValueOrDefault();

		public int CurrentHealth => ReadHealth(_healthField, _trackedHealth, isHealth: true);

		public int MaxHealth => Math.Max(1, ReadHealth(_maxHealthField, _trackedMaxHealth, isHealth: false));

		public ReflectionGameApi(ManualLogSource log, GameEventHub events, DynamicPatchResolver resolver, InvulnerabilityLeaseService leases)
		{
			_log = log;
			_events = events;
			_resolver = resolver;
			_leases = leases;
			_healthField = _resolver.ResolveField("player.health.get");
			_maxHealthField = _resolver.ResolveField("player.maxhealth.get");
			_explosions = new PlayerExplosionSpawner(log, resolver);
			_nativeExplosions = new PimpiloExplosionSpawner(log);
			MaxHealthHudSync.Configure(log);
			if (_healthField == null || _maxHealthField == null)
			{
				_log.LogWarning((object)"Health field binding is not fully resolved; rage UI will fall back to event-tracked health (unverified).");
				_events.PlayerDamageAfter += OnTrackedDamage;
				_events.HealResolved += OnTrackedHeal;
				_events.BenchRested += OnTrackedBench;
				_events.PlayerDied += OnTrackedDeath;
			}
			_events.PlayerDamageAfter += OnHealthSource;
			_events.HealResolved += OnHealthSource;
			_events.BenchRested += OnHealthSource;
			_events.PlayerDied += OnHealthSource;
			_events.SceneChanged += OnHealthSource;
		}

		public bool TryHeal(int amount, string reason)
		{
			HeroController instance = HeroController.instance;
			if ((Object)(object)instance == (Object)null || amount <= 0)
			{
				return false;
			}
			try
			{
				instance.AddHealth(amount);
				return true;
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"TryHeal failed: amount={amount}, reason={reason}, error={arg}");
				return false;
			}
		}

		public bool TrySpendSilk(int amount, string reason)
		{
			HeroController instance = HeroController.instance;
			if (instance?.playerData == null)
			{
				return false;
			}
			if (amount < 0)
			{
				return false;
			}
			if (instance.playerData.silk < amount)
			{
				return false;
			}
			try
			{
				instance.TakeSilk(amount, (SilkTakeSource)4);
				return true;
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"TrySpendSilk failed: amount={amount}, reason={reason}, error={arg}");
				return false;
			}
		}

		public void AddSilk(int amount, string reason)
		{
			HeroController instance = HeroController.instance;
			if ((Object)(object)instance == (Object)null || amount <= 0)
			{
				return;
			}
			try
			{
				instance.AddSilk(amount, false, (SilkAddSource)0, false);
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"AddSilk failed: amount={amount}, reason={reason}, error={arg}");
			}
		}

		public void AddShards(int amount, string reason)
		{
			if (amount <= 0)
			{
				return;
			}
			PlayerData instance = PlayerData.instance;
			if (instance == null)
			{
				return;
			}
			try
			{
				instance.AddShards(amount);
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"AddShards failed: amount={amount}, reason={reason}, error={arg}");
			}
		}

		public void SetTemporaryCharmLevelOffset(int offset, string source)
		{
			_log.LogWarning((object)$"Charm level projection is not bound yet. offset={offset}, source={source}");
		}

		public void SetTemporaryMaxHealth(int? maxHealth)
		{
			PlayerData val = HeroController.instance?.playerData;
			if (val == null)
			{
				return;
			}
			try
			{
				if (maxHealth.HasValue && maxHealth.Value > 0)
				{
					if (!_maxHealthProjected)
					{
						_originalMaxHealthBase = val.maxHealthBase;
						_originalHealth = val.health;
						_maxHealthProjected = true;
					}
					int num = maxHealth.Value - val.maxHealthBase;
					if (num != 0)
					{
						val.AddToMaxHealth(num);
					}
					_trackedMaxHealth = Math.Max(1, val.maxHealth);
					if (val.health > val.maxHealth)
					{
						val.health = val.maxHealth;
					}
					EventRegister.SendEvent("MAX HP UP", (GameObject)null);
					EventRegister.SendEvent(EventRegisterEvents.HealthUpdate, (GameObject)null);
					MaxHealthHudSync.Apply(maxHealth.Value);
					PublishHealthIfChanged();
					_log.LogDebug((object)$"[Rage] temporary max health projection -> {maxHealth.Value} (originalBase={_originalMaxHealthBase}).");
				}
				else
				{
					if (!_maxHealthProjected)
					{
						return;
					}
					if (_originalMaxHealthBase.HasValue)
					{
						int num2 = _originalMaxHealthBase.Value - val.maxHealthBase;
						if (num2 != 0)
						{
							val.AddToMaxHealth(num2);
						}
						if (val.health > 0)
						{
							val.health = Math.Min(_originalHealth ?? val.health, val.maxHealth);
						}
						_trackedMaxHealth = Math.Max(1, val.maxHealth);
					}
					EventRegister.SendEvent("MAX HP UP", (GameObject)null);
					EventRegister.SendEvent(EventRegisterEvents.HealthUpdate, (GameObject)null);
					MaxHealthHudSync.Apply(null);
					PublishHealthIfChanged();
					_maxHealthProjected = false;
					_originalMaxHealthBase = null;
					_originalHealth = null;
					_log.LogDebug((object)"[Rage] temporary max health projection restored.");
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[Rage] SetTemporaryMaxHealth failed: " + ex.Message));
			}
		}

		public void ClearBlueHealth(string reason)
		{
			try
			{
				PlayerData val = HeroController.instance?.playerData;
				GameManager instance = GameManager.instance;
				if (val != null)
				{
					val.healthBlue = 0;
				}
				if (instance != null)
				{
					instance.UpdateBlueHealth();
				}
				EventRegister.SendEvent(EventRegisterEvents.UpdateBlueHealth, (GameObject)null);
				_log.LogDebug((object)("[Rage] blue health cleared (reason=" + reason + ")."));
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[BlueHealth] ClearBlueHealth failed: " + ex.Message));
			}
		}

		public IDisposable AcquireInvulnerability(string source, double maxDurationSeconds)
		{
			return _leases.Acquire(source, maxDurationSeconds);
		}

		public bool TryInvokeVanillaAction(string bindingId)
		{
			_log.LogWarning((object)("Vanilla action is not bound: " + bindingId));
			return false;
		}

		public void SpawnAdditionalDamage(AdditionalDamageCommand command)
		{
			_log.LogWarning((object)$"Additional damage spawn is not bound: {command}");
		}

		public bool SpawnPlayerExplosion(double damage, string sourceTag, float radius)
		{
			return _explosions?.Spawn(damage, radius) ?? false;
		}

		public bool SpawnPlayerExplosionAt(double damage, string sourceTag, float radius, Vector3 position)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return _explosions?.SpawnAt(damage, radius, position) ?? false;
		}

		public bool SpawnNativeExplosion()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			HeroController instance = HeroController.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			return SpawnNativeExplosionAt(((Component)instance).transform.position);
		}

		public bool SpawnNativeExplosionAt(Vector3 position)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return _nativeExplosions?.Spawn(position) ?? false;
		}

		public bool TryGetToolColor(string toolId, out ToolColorKind color)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected I4, but got Unknown
			color = ToolColorKind.Skill;
			if (string.IsNullOrWhiteSpace(toolId))
			{
				return false;
			}
			try
			{
				ToolItem toolByName = ToolItemManager.GetToolByName(toolId);
				if ((Object)(object)toolByName == (Object)null)
				{
					return false;
				}
				ToolItemType type = toolByName.Type;
				color = (int)type switch
				{
					0 => ToolColorKind.Red, 
					1 => ToolColorKind.Blue, 
					2 => ToolColorKind.Yellow, 
					_ => ToolColorKind.Skill, 
				};
				return true;
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("TryGetToolColor failed for '" + toolId + "': " + ex.Message));
				return false;
			}
		}

		public void Dispose()
		{
			_events.PlayerDamageAfter -= OnHealthSource;
			_events.HealResolved -= OnHealthSource;
			_events.BenchRested -= OnHealthSource;
			_events.PlayerDied -= OnHealthSource;
			_events.SceneChanged -= OnHealthSource;
			_events.PlayerDamageAfter -= OnTrackedDamage;
			_events.HealResolved -= OnTrackedHeal;
			_events.BenchRested -= OnTrackedBench;
			_events.PlayerDied -= OnTrackedDeath;
		}

		private void OnHealthSource(PlayerDamageEvent e)
		{
			PublishHealthIfChanged();
		}

		private void OnHealthSource(HealEvent e)
		{
			PublishHealthIfChanged();
		}

		private void OnHealthSource()
		{
			PublishHealthIfChanged();
		}

		private void OnHealthSource(string scene)
		{
			PublishHealthIfChanged();
		}

		private void PublishHealthIfChanged()
		{
			try
			{
				int currentHealth = CurrentHealth;
				int maxHealth = MaxHealth;
				if (currentHealth != _lastPublishedHealth || maxHealth != _lastPublishedMaxHealth)
				{
					int lastPublishedHealth = _lastPublishedHealth;
					_lastPublishedHealth = currentHealth;
					_lastPublishedMaxHealth = maxHealth;
					_events.PublishHealthChanged(new HealthChangedEvent(lastPublishedHealth, currentHealth, maxHealth));
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[HealthMonitor] publish failed: " + ex.Message));
			}
		}

		private int ReadHealth(FieldInfo? field, int fallback, bool isHealth)
		{
			try
			{
				PlayerData val = HeroController.instance?.playerData;
				if (val == null)
				{
					return fallback;
				}
				if (field != null)
				{
					return (int)field.GetValue(val);
				}
				return isHealth ? val.health : val.maxHealth;
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("Health field read failed; using tracked fallback. " + ex.Message));
				return fallback;
			}
		}

		private void OnTrackedDamage(PlayerDamageEvent e)
		{
			if (!e.Cancelled)
			{
				_trackedHealth = Math.Max(0, _trackedHealth - e.MaskDamage);
			}
		}

		private void OnTrackedHeal(HealEvent e)
		{
			_trackedHealth = Math.Min(_trackedMaxHealth, _trackedHealth + e.Applied);
		}

		private void OnTrackedBench()
		{
			_trackedHealth = _trackedMaxHealth;
		}

		private void OnTrackedDeath()
		{
			_trackedHealth = 0;
		}
	}
	public sealed class StatusIconTextureService : IDisposable
	{
		private const int TextureSize = 64;

		private const float PixelsPerUnit = 100f;

		private readonly ManualLogSource _log;

		private readonly StatusIconOptions _options;

		private readonly Dictionary<string, Sprite> _icons = new Dictionary<string, Sprite>(StringComparer.Ordinal);

		private readonly Dictionary<string, Sprite> _dynamicIcons = new Dictionary<string, Sprite>(StringComparer.Ordinal);

		private readonly Dictionary<string, float> _dynamicScales = new Dictionary<string, float>(StringComparer.Ordinal);

		private readonly Dictionary<string, Color> _ringColors = new Dictionary<string, Color>(StringComparer.Ordinal);

		private readonly Dictionary<string, Color> _iconTints = new Dictionary<string, Color>(StringComparer.Ordinal);

		private readonly Dictionary<string, bool> _hudVariants = new Dictionary<string, bool>(StringComparer.Ordinal);

		private readonly List<Texture2D> _ownedTextures = new List<Texture2D>();

		private Sprite? _ringSprite;

		public static Func<string, bool>? IsWhiteToolIconKey { get; set; }

		public Sprite RingSprite => _ringSprite ?? (_ringSprite = CreateRingSprite());

		public StatusIconTextureService(ManualLogSource log, StatusIconOptions options)
		{
			_log = log;
			_options = options;
		}

		public bool IsIconEnabled(string key)
		{
			return _options.GetIcon(key).Enabled;
		}

		public float GetIconScale(string key)
		{
			if (_dynamicScales.TryGetValue(key, out var value) && value > 0f)
			{
				return value;
			}
			Func<string, bool>? isWhiteToolIconKey = IsWhiteToolIconKey;
			if (isWhiteToolIconKey != null && isWhiteToolIconKey(key))
			{
				return 0.765f;
			}
			if (!_hudVariants.TryGetValue(key, out var value2))
			{
				return 1f;
			}
			if (!value2)
			{
				return 0.7f;
			}
			return 1.4f;
		}

		public Color GetIconTint(string key)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (_iconTints.TryGetValue(key, out var value))
			{
				return value;
			}
			Color val = ParseColor(_options.GetIcon(key).IconColorHex, Color.white);
			_iconTints[key] = val;
			return val;
		}

		public Sprite GetIconSprite(string key)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			if (_dynamicIcons.TryGetValue(key, out Sprite value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if (_icons.TryGetValue(key, out Sprite value2))
			{
				return value2;
			}
			string texture = _options.GetIcon(key).Texture;
			Sprite val;
			if (string.IsNullOrWhiteSpace(texture) || texture == "placeholder")
			{
				val = CreatePlaceholderSprite(key, GetRingColor(key));
				_hudVariants[key] = false;
			}
			else if (texture.StartsWith("game:", StringComparison.OrdinalIgnoreCase))
			{
				string text = texture.Substring("game:".Length).Trim();
				if (text.StartsWith("tool:", StringComparison.OrdinalIgnoreCase))
				{
					text = text.Substring("tool:".Length).Trim();
				}
				val = LoadGameToolSprite(text, key) ?? CreatePlaceholderSprite(key, GetRingColor(key));
			}
			else
			{
				val = LoadPngSprite(key, texture) ?? CreatePlaceholderSprite(key, GetRingColor(key));
				_hudVariants[key] = false;
			}
			_icons[key] = val;
			return val;
		}

		public void SetDynamicIconSprite(string key, Sprite? sprite)
		{
			if (!string.IsNullOrEmpty(key))
			{
				if ((Object)(object)sprite == (Object)null)
				{
					_dynamicIcons.Remove(key);
				}
				else
				{
					_dynamicIcons[key] = sprite;
				}
			}
		}

		public void SetDynamicIconScale(string key, float? scale)
		{
			if (!string.IsNullOrEmpty(key))
			{
				if (!scale.HasValue || scale <= 0f)
				{
					_dynamicScales.Remove(key);
				}
				else
				{
					_dynamicScales[key] = scale.Value;
				}
			}
		}

		public Color GetRingColor(string key)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (_ringColors.TryGetValue(key, out var value))
			{
				return value;
			}
			Color val = ParseColor(_options.GetIcon(key).ColorHex, Color.white);
			_ringColors[key] = val;
			return val;
		}

		public void Dispose()
		{
			foreach (Texture2D ownedTexture in _ownedTextures)
			{
				if ((Object)(object)ownedTexture != (Object)null)
				{
					Object.Destroy((Object)(object)ownedTexture);
				}
			}
			_ownedTextures.Clear();
			_icons.Clear();
			_dynamicIcons.Clear();
			_dynamicScales.Clear();
			_ringSprite = null;
		}

		private Sprite? LoadPngSprite(string key, string path)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			string text = (Path.IsPathRooted(path) ? path : Path.Combine(Paths.PluginPath, "CrestsEvolve", "Textures", path));
			if (!File.Exists(text))
			{
				_log.LogWarning((object)("[StatusIcons] texture file not found for '" + key + "': " + text + "; using placeholder."));
				return null;
			}
			try
			{
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!ImageConversion.LoadImage(val, File.ReadAllBytes(text)))
				{
					_log.LogWarning((object)("[StatusIcons] failed to decode '" + text + "' for '" + key + "'; using placeholder."));
					Object.Destroy((Object)(object)val);
					return null;
				}
				((Texture)val).filterMode = (FilterMode)1;
				_ownedTextures.Add(val);
				return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"[StatusIcons] loading '{text}' for '{key}' failed: {arg}");
				return null;
			}
		}

		private Sprite? LoadGameToolSprite(string toolName, string key)
		{
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(toolName))
			{
				_log.LogWarning((object)("[StatusIcons] empty game tool name for '" + key + "'; using placeholder."));
				return null;
			}
			try
			{
				ToolItem toolByName = ToolItemManager.GetToolByName(toolName);
				if ((Object)(object)toolByName == (Object)null)
				{
					_log.LogWarning((object)("[StatusIcons] game tool '" + toolName + "' not found for '" + key + "'; using fallback."));
					return FallbackForRageFury(key);
				}
				Sprite val = toolByName.GetHudSprite((IconVariants)0);
				string text = "GetHudSprite(Default)";
				if ((Object)(object)val == (Object)null)
				{
					val = toolByName.InventorySpriteModified;
					text = "InventorySpriteModified";
				}
				if ((Object)(object)val == (Object)null)
				{
					val = toolByName.InventorySpriteBase;
					text = "InventorySpriteBase";
				}
				if ((Object)(object)val == (Object)null)
				{
					_log.LogWarning((object)("[StatusIcons] game tool '" + toolName + "' has no HUD sprite for '" + key + "'; using fallback."));
					return FallbackForRageFury(key);
				}
				if (!string.IsNullOrEmpty(((Object)val).name))
				{
					Rect rect = val.rect;
					if (!(((Rect)(ref rect)).width <= 0f))
					{
						rect = val.rect;
						if (!(((Rect)(ref rect)).height <= 0f))
						{
							_log.LogInfo((object)("[StatusIcons][probe] game sprite bound: " + key + " <- tool '" + toolName + "' type=" + ((object)toolByName).GetType().Name + " via " + text + " sprite '" + ((Object)val).name + "'"));
							_hudVariants[key] = text == "GetHudSprite(Default)";
							return val;
						}
					}
				}
				_log.LogWarning((object)("[StatusIcons] game tool '" + toolName + "' sprite invalid for '" + key + "' (name='" + ((Object)val).name + "'); using fallback."));
				return FallbackForRageFury(key);
			}
			catch (Exception arg)
			{
				_log.LogError((object)$"[StatusIcons] loading game tool sprite '{toolName}' for '{key}' failed: {arg}");
				return null;
			}
		}

		private Sprite? FallbackForRageFury(string key)
		{
			if (!string.Equals(key, "rage.fury", StringComparison.OrdinalIgnoreCase))
			{
				return null;
			}
			Sprite? obj = LoadPngSprite(key, "Fury_of_the_Fallen.png");
			if ((Object)(object)obj != (Object)null)
			{
				_hudVariants[key] = false;
			}
			return obj;
		}

		private Sprite CreatePlaceholderSprite(string key, Color color)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false);
			_ownedTextures.Add(val);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(31.5f, 31.5f);
			float num = 30f;
			Color[] array = (Color[])(object)new Color[4096];
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					float num2 = ((Vector2.Distance(new Vector2((float)j, (float)i), val2) <= num) ? 1f : 0f);
					array[i * 64 + j] = new Color(color.r, color.g, color.b, num2);
				}
			}
			val.SetPixels(array);
			val.Apply();
			((Texture)val).filterMode = (FilterMode)1;
			return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f);
		}

		private Sprite CreateRingSprite()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false);
			_ownedTextures.Add(val);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(31.5f, 31.5f);
			Color[] array = (Color[])(object)new Color[4096];
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					float num = Vector2.Distance(new Vector2((float)j, (float)i), val2);
					float num2 = ((num <= 30f && num >= 21f) ? 1f : 0f);
					array[i * 64 + j] = new Color(1f, 1f, 1f, num2);
				}
			}
			val.SetPixels(array);
			val.Apply();
			((Texture)val).filterMode = (FilterMode)1;
			return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f);
		}

		private static Color ParseColor(string hex, Color fallback)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			Color result = default(Color);
			if (!ColorUtility.TryParseHtmlString(hex, ref result))
			{
				return fallback;
			}
			return result;
		}
	}
	public sealed class StatusIconTickRunner : MonoBehaviour
	{
		private readonly List<Action<float>> _ticks = new List<Action<float>>();

		public void Register(Action<float> tick)
		{
			_ticks.Add(tick);
		}

		private void Update()
		{
			if ((Object)(object)HeroController.instance == (Object)null || Time.deltaTime <= 0f)
			{
				return;
			}
			float deltaTime = Time.deltaTime;
			foreach (Action<float> tick in _ticks)
			{
				try
				{
					tick(deltaTime);
				}
				catch (Exception arg)
				{
					Debug.LogWarning((object)$"[StatusIconTickRunner] tick failed: {arg}");
				}
			}
		}
	}
	public static class ToolEquipsDiagnostics
	{
		public static bool Enabled { get; set; }
	}
	public static class ToolEquipsSnapshot
	{
		public static string FormatSlots(string crestId, IReadOnlyList<string?>? slots)
		{
			List<string> values = ((slots == null) ? new List<string> { "<no-slots>" } : slots.Select((string s) => (!string.IsNullOrEmpty(s)) ? s : "<empty>").ToList());
			return crestId + ": [" + string.Join(", ", values) + "]";
		}

		public static IReadOnlyList<string> FindIssues(string crestId, IReadOnlyList<string?>? slots, int expectedSlotCount)
		{
			List<string> list = new List<string>();
			if (slots == null)
			{
				return list;
			}
			if (slots.Count > expectedSlotCount)
			{
				list.Add($"{crestId}: slot count {slots.Count} > expected {expectedSlotCount}");
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < slots.Count; i++)
			{
				string text = slots[i];
				if (!string.IsNullOrEmpty(text) && !hashSet.Add(text))
				{
					list.Add($"{crestId}: duplicate tool '{text}' at slot {i}");
				}
			}
			return list;
		}

		public static void Log(ManualLogSource log, string context)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (log == null || !ToolEquipsDiagnostics.Enabled)
			{
				return;
			}
			try
			{
				PlayerData instance = PlayerData.instance;
				if (instance == null)
				{
					return;
				}
				List<ToolCrest> allCrests = ToolItemManager.GetAllCrests();
				if (allCrests == null)
				{
					return;
				}
				foreach (ToolCrest item in allCrests)
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					List<string> slots = ((SerializableNamedList<Data, NamedData>)(object)instance.ToolEquips).GetData(item.name).Slots?.Select((SlotData s) => s.EquippedTool).ToList();
					log.LogInfo((object)("[ToolEquipsDiagnostics][" + context + "] " + FormatSlots(item.name, slots)));
					string name = item.name;
					SlotInfo[] slots2 = item.Slots;
					foreach (string item2 in FindIssues(name, slots, (slots2 != null) ? slots2.Length : 0))
					{
						log.LogWarning((object)("[ToolEquipsDiagnostics][" + context + "] " + item2));
					}
				}
			}
			catch (Exception ex)
			{
				log.LogWarning((object)("[ToolEquipsDiagnostics][" + context + "] snapshot failed: " + ex.Message));
			}
		}
	}
	public static class ToolRowLocator
	{
		public static Transform? Resolve(string? configuredPath, Transform bindOrbFrame)
		{
			if (!string.IsNullOrWhiteSpace(configuredPath) && configuredPath != "auto")
			{
				Transform val = ResolvePath(configuredPath, bindOrbFrame);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return FindVanillaToolRow(bindOrbFrame);
		}

		private static Transform? ResolvePath(string path, Transform bindOrbFrame)
		{
			Transform val = (((Object)(object)bindOrbFrame != (Object)null) ? bindOrbFrame.root : null);
			if ((Object)(object)val != (Object)null)
			{
				Transform val2 = val.Find(path);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			GameObject val3 = GameObject.Find(path);
			if ((Object)(object)val3 != (Object)null)
			{
				return val3.transform;
			}
			if (!((Object)(object)bindOrbFrame != (Object)null))
			{
				return null;
			}
			return bindOrbFrame.Find(path);
		}

		private static Transform? FindVanillaToolRow(Transform bindOrbFrame)
		{
			if ((Object)(object)bindOrbFrame == (Object)null)
			{
				return null;
			}
			List<Transform> list = new List<Transform>();
			Transform val = bindOrbFrame;
			int num = 0;
			while ((Object)(object)val != (Object)null && num < 8)
			{
				CollectToolCandidates(val, list, 0, 3);
				num++;
				val = val.parent;
			}
			Transform result = null;
			int num2 = -1;
			foreach (Transform item in list)
			{
				int num3 = ScoreToolRow(item);
				if (num3 > num2)
				{
					num2 = num3;
					result = item;
				}
			}
			return result;
		}

		private static void CollectToolCandidates(Transform parent, List<Transform> candidates, int depth, int maxDepth)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			if (depth > maxDepth)
			{
				return;
			}
			foreach (Transform item in parent)
			{
				Transform val = item;
				if ((Object)(object)((Component)val).GetComponent<ToolHudIcon>() != (Object)null || ((Object)val).name.IndexOf("Tool", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					candidates.Add(val);
				}
				CollectToolCandidates(val, candidates, depth + 1, maxDepth);
			}
		}

		private static int ScoreToolRow(Transform candidate)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			int num = 0;
			if ((Object)(object)((Component)candidate).GetComponent<ToolHudIcon>() != (Object)null)
			{
				num += 100;
			}
			if (((Object)candidate).name.IndexOf("Tool", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				num += 20;
			}
			if (((Object)candidate).name.IndexOf("Icons", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				num += 30;
			}
			int num2 = 0;
			foreach (Transform item in candidate)
			{
				Transform val = item;
				if ((Object)(object)((Component)val).GetComponent<ToolHudIcon>() != (Object)null)
				{
					num += 50;
					num2++;
				}
				if ((Object)(object)((Component)val).GetComponent<SpriteRenderer>() != (Object)null || (Object)(object)((Component)val).GetComponent<Image>() != (Object)null)
				{
					num++;
				}
			}
			if (num2 > 0 && (Object)(object)((Component)candidate).GetComponent<ToolHudIcon>() == (Object)null)
			{
				num += 40;
			}
			return num;
		}
	}
	public sealed class UnityRandom : IRandom
	{
		public double NextDouble()
		{
			return Random.value;
		}
	}
	public static class WandererRuneBridge
	{
		public static Func<bool> IsActive { get; set; } = () => false;

		public static Func<int> LayerCount { get; set; } = () => 0;

		public static Func<bool> IsFullLayers { get; set; } = () => false;
	}
	public static class WhiteSlotPlacementRules
	{
		public static bool IsWhiteTool(ToolItemType toolType, ToolItemType whiteType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return toolType == whiteType;
		}

		public static bool IsToolAllowedInSlot(ToolItemType slotType, ToolItemType toolType, ToolItemType whiteType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (toolType == whiteType)
			{
				return (int)slotType > 0;
			}
			if (slotType == whiteType)
			{
				if ((int)toolType != 1 && (int)toolType != 2)
				{
					return toolType == whiteType;
				}
				return true;
			}
			return slotType == toolType;
		}
	}
	public static class WhiteToolSystem
	{
		private static readonly HashSet<string> _registeredTools = new HashSet<string>(StringComparer.Ordinal);

		private const string WhiteHeaderTexture = "19.png";

		private const float WhiteHeaderWorldWidth = 1f;

		public static ToolItemType? WhiteType { get; private set; }

		public static bool Installed { get; private set; }

		public static bool IsEquippedInWhiteSlot(string toolName)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if (!WhiteType.HasValue || string.IsNullOrEmpty(toolName))
			{
				return false;
			}
			try
			{
				PlayerData instance = PlayerData.instance;
				if (instance == null || string.IsNullOrEmpty(instance.CurrentCrestID))
				{
					return false;
				}
				ToolCrest crestByName = ToolItemManager.GetCrestByName(instance.CurrentCrestID);
				if ((Object)(object)crestByName == (Object)null || crestByName.Slots == null)
				{
					return false;
				}
				Data data = ((SerializableNamedList<Data, NamedData>)(object)instance.ToolEquips).GetData(instance.CurrentCrestID);
				if (data.Slots == null)
				{
					return false;
				}
				for (int i = 0; i < Math.Min(crestByName.Slots.Length, data.Slots.Count); i++)
				{
					if (crestByName.Slots[i].Type == WhiteType.Value && string.Equals(data.Slots[i].EquippedTool, toolName, StringComparison.Ordinal))
					{
						return true;
					}
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[WhiteToolSystem] white-slot query failed for '" + toolName + "': " + ex.Message));
			}
			return false;
		}

		public static bool IsEquippedAnywhere(string toolName)
		{
			if (string.IsNullOrEmpty(toolName))
			{
				return false;
			}
			try
			{
				if (ToolItemManager.IsToolEquipped(toolName))
				{
					return true;
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[WhiteToolSystem] IsToolEquipped query failed for '" + toolName + "': " + ex.Message));
			}
			return IsEquippedInWhiteSlot(toolName);
		}

		public static bool TryInstall(NeedleforgeAdapter adapter, ManualLogSource log)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (Installed)
			{
				return true;
			}
			if (!adapter.TryAddWhiteToolColor(out var type))
			{
				return false;
			}
			Sprite val = LoadIconSprite(log, "19.png", null, 1f);
			if ((Object)(object)val != (Object)null)
			{
				adapter.TrySetWhiteToolHeader(val);
			}
			else
			{
				log.LogWarning((object)"[WhiteToolSystem] white section header texture missing; keeping the cloned Blue header.");
			}
			WhiteType = type;
			Installed = true;
			log.LogInfo((object)"[WhiteToolSystem] white tool type installed; individual tools are registered by their owning mods.");
			return true;
		}

		public static void RegisterAllWhiteTools(ManualLogSource log)
		{
			foreach (WhiteToolSpec item in WhiteToolCatalog.All)
			{
				RegisterWhiteTool(item.Name, item.TextureFile, item.RingColorHex, log, item.PpuOverride);
			}
		}

		public static bool RegisterWhiteTool(string name, string textureFile, string ringColorHex, ManualLogSource log, float? ppuOverride = null, float targetWorldWidth = 1.28f)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if (!_registeredTools.Add(name))
			{
				log.LogDebug((object)("[WhiteToolSystem] tool '" + name + "' already registered; skipping duplicate."));
				return true;
			}
			if (!WhiteType.HasValue || !Installed)
			{
				_registeredTools.Remove(name);
				log.LogWarning((object)("[WhiteToolSystem] white type not installed yet; cannot register '" + name + "'."));
				return false;
			}
			Sprite val = LoadIconSprite(log, textureFile, ppuOverride, targetWorldWidth);
			if ((Object)(object)val == (Object)null)
			{
				_registeredTools.Remove(name);
				log.LogWarning((object)("[WhiteToolSystem] texture missing for " + name + "; tool skipped."));
				return false;
			}
			return RegisterTool(name, WhiteType.Value, val, log);
		}

		private static bool RegisterTool(string name, ToolItemType type, Sprite sprite, ManualLogSource log)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				NeedleforgePlugin.AddTool(name, type, new LocalisedString
				{
					Key = name,
					Sheet = "Mods.local.crestsevolve"
				}, new LocalisedString
				{
					Key = name + "Desc",
					Sheet = "Mods.local.crestsevolve"
				}, sprite);
				log.LogInfo((object)("[WhiteToolSystem] white tool registered: " + name));
				return true;
			}
			catch (Exception arg)
			{
				log.LogError((object)$"[WhiteToolSystem] register failed for {name}: {arg}");
				return false;
			}
		}

		private static Sprite? LoadIconSprite(ManualLogSource log, string fileName, float? ppuOverride = null, float targetWorldWidth = 1.28f)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			string text = Path.Combine(Paths.PluginPath, "CrestsEvolve", "Textures", fileName);
			if (!File.Exists(text))
			{
				log.LogWarning((object)("[WhiteToolSystem] texture not found: " + text));
				return null;
			}
			try
			{
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (!ImageConversion.LoadImage(val, File.ReadAllBytes(text)))
				{
					Object.Destroy((Object)(object)val);
					return null;
				}
				((Texture)val).filterMode = (FilterMode)1;
				float num = ppuOverride ?? ((float)((Texture)val).width / targetWorldWidth);
				return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), num);
			}
			catch (Exception arg)
			{
				log.LogError((object)$"[WhiteToolSystem] texture load failed for {fileName}: {arg}");
				return null;
			}
		}
	}
	public static class WitchRuneBridge
	{
		public static Func<bool> IsGraspCharged { get; set; } = () => false;

		public static Func<int> GraspLayers { get; set; } = () => 0;

		public static Func<int> AftershockLayers { get; set; } = () => 0;

		public static Func<bool> IsBindChainActive { get; set; } = () => false;

		public static Func<bool> IsGraspActive { get; set; } = () => false;

		public static Action? AcquireDashInvulnerability { get; set; }
	}
}
namespace CrestsEvolve.GameInterop.Reflection
{
	public static class ReflectionLookup
	{
		private const BindingFlags Flags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public static object? ReadMember(object target, params string[] names)
		{
			Type type = target.GetType();
			foreach (string text in names)
			{
				FieldInfo fieldInfo = FindField(type, text);
				if (fieldInfo != null)
				{
					try
					{
						return fieldInfo.GetValue(target);
					}
					catch
					{
					}
				}
				PropertyInfo propertyInfo = FindProperty(type, text);
				if (propertyInfo != null && propertyInfo.CanRead)
				{
					try
					{
						return propertyInfo.GetValue(target, null);
					}
					catch
					{
					}
				}
			}
			return null;
		}

		public static object? ReadStaticMember(Type? type, params string[] names)
		{
			if (type == null)
			{
				return null;
			}
			foreach (string text in names)
			{
				FieldInfo fieldInfo = FindField(type, text);
				if (fieldInfo != null && fieldInfo.IsStatic)
				{
					try
					{
						return fieldInfo.GetValue(null);
					}
					catch
					{
					}
				}
				PropertyInfo propertyInfo = FindProperty(type, text);
				MethodInfo methodInfo = propertyInfo?.GetGetMethod(nonPublic: true);
				if (propertyInfo != null && (object)methodInfo != null && methodInfo.IsStatic)
				{
					try
					{
						return propertyInfo.GetValue(null, null);
					}
					catch
					{
					}
				}
			}
			return null;
		}

		public static FieldInfo? FindField(Type type, params string[] names)
		{
			foreach (string name in names)
			{
				FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					return field;
				}
				FieldInfo fieldInfo = type.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((FieldInfo x) => string.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase));
				if (fieldInfo != null)
				{
					return fieldInfo;
				}
			}
			return null;
		}

		public static PropertyInfo? FindProperty(Type type, params string[] names)
		{
			foreach (string name in names)
			{
				PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null)
				{
					return property;
				}
				PropertyInfo propertyInfo = type.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((PropertyInfo x) => string.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase));
				if (propertyInfo != null)
				{
					return propertyInfo;
				}
			}
			return null;
		}

		public static MethodInfo? FindMethod(Type type, string name, params Type[] parameters)
		{
			if (parameters.Length != 0)
			{
				return type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo x) => string.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase) && (from p in x.GetParameters()
					select p.ParameterType).SequenceEqual(parameters));
			}
			return type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault((MethodInfo x) => string.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase) && x.GetParameters().Length == 0);
		}

		public static PropertyInfo? FindBoolProperty(Type type, params string[] names)
		{
			return names.Select((string name) => FindProperty(type, name)).FirstOrDefault((PropertyInfo property) => property?.PropertyType == typeof(bool));
		}

		public static MethodInfo? FindBoolMethod(Type type, params string[] names)
		{
			return names.Select((string name) => FindMethod(type, name)).FirstOrDefault((MethodInfo method) => method?.ReturnType == typeof(bool));
		}

		public static PropertyInfo? FindVectorProperty(Type type, params string[] names)
		{
			return names.Select((string name) => FindProperty(type, name)).FirstOrDefault((PropertyInfo property) => property?.PropertyType == typeof(Vector2));
		}

		public static FieldInfo? FindVectorField(Type type, params string[] names)
		{
			return names.Select((string name) => FindField(type, name)).FirstOrDefault((FieldInfo field) => field?.FieldType == typeof(Vector2));
		}

		public static MethodInfo? FindVectorMethod(Type type, params string[] names)
		{
			return names.Select((string name) => FindMethod(type, name)).FirstOrDefault((MethodInfo method) => method?.ReturnType == typeof(Vector2));
		}

		public static IEnumerable<string> GetMemberNames(Type type)
		{
			return (from x in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				select x.Name).Concat(from x in type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
				select x.Name).Distinct<string>(StringComparer.OrdinalIgnoreCase).OrderBy<string, string>((string x) => x, StringComparer.OrdinalIgnoreCase);
		}
	}
}
namespace CrestsEvolve.GameInterop.Patches
{
	public static class ToolDescriptionPatch
	{
		private static ManualLogSource? _log;

		private static bool _warned;

		public static void Configure(ManualLogSource log)
		{
			_log = log;
			_warned = false;
		}

		public static void Postfix(InventoryItemTool __instance, ref string __result)
		{
			try
			{
				if (!string.IsNullOrEmpty(__result))
				{
					ToolItem val = ((__instance != null) ? ((InventoryItemToolBase)__instance).ItemData : null);
					if (!((Object)(object)val == (Object)null) && ToolDescriptionRegistry.TryGetSuffix(val.name, out string suffix))
					{
						__result = __result + "\n\n" + suffix;
					}
				}
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
			}
		}

		private static void WarnOnce(Exception ex)
		{
			if (!_warned)
			{
				_warned = true;
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogWarning((object)("[ToolDescription] disabled: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}
	}
	internal static class WhiteSlotInstaller
	{
		private enum Direction
		{
			None,
			Left,
			Right,
			Up,
			Down
		}

		private static ManualLogSource? _log;

		public static ToolItemType? WhiteType { get; set; }

		public static bool Enabled { get; set; }

		public static void Configure(ManualLogSource log)
		{
			_log = log;
		}

		public static void Postfix(ToolItemManager __instance)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			if (!Enabled || !WhiteType.HasValue)
			{
				return;
			}
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(ToolCrest), "slots");
				foreach (ToolCrest allCrest in ToolItemManager.GetAllCrests())
				{
					SlotInfo[] array = (fieldInfo.GetValue(allCrest) as SlotInfo[]) ?? Array.Empty<SlotInfo>();
					int num = array.Count((SlotInfo s) => s.Type == WhiteType.Value);
					int num2 = Math.Max(0, 3 - num);
					if (num2 > 0)
					{
						SlotInfo[] second = ((IEnumerable<SlotInfo>)(object)new SlotInfo[3]
						{
							MakeSlot(-1.5f, 4.2f),
							MakeSlot(0f, 4.2f),
							MakeSlot(1.5f, 4.2f)
						}).Take(num2).ToArray();
						fieldInfo.SetValue(allCrest, array.Concat(second).ToArray());
					}
					SlotInfo[] slots = (fieldInfo.GetValue(allCrest) as SlotInfo[]) ?? Array.Empty<SlotInfo>();
					fieldInfo.SetValue(allCrest, RecomputeNavigation(slots));
					PlayerData instance = PlayerData.instance;
					if (instance != null)
					{
						Data data = ((SerializableNamedList<Data, NamedData>)(object)instance.ToolEquips).GetData(allCrest.name);
						SlotInfo[] array2 = (fieldInfo.GetValue(allCrest) as SlotInfo[]) ?? Array.Empty<SlotInfo>();
						if (data.Slots == null)
						{
							data.Slots = new List<SlotData>();
						}
						while (data.Slots.Count < array2.Length)
						{
							data.Slots.Add(new SlotData
							{
								IsUnlocked = true
							});
						}
						if (data.Slots.Count > array2.Length)
						{
							data.Slots.RemoveRange(array2.Length, data.Slots.Count - array2.Length);
						}
						SanitizeWhiteSlotDuplicates(data.Slots, array2, WhiteType.Value);
						((SerializableNamedList<Data, NamedData>)(object)instance.ToolEquips).SetData(allCrest.name, data);
					}
				}
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogInfo((object)$"[WhiteSlotInstaller] white slots added to {ToolItemManager.GetAllCrests().Count()} crests.");
				}
				TryRefreshEquippedState();
			}
			catch (Exception arg)
			{
				ManualLogSource? log2 = _log;
				if (log2 != null)
				{
					log2.LogError((object)$"[WhiteSlotInstaller] failed to add white slots: {arg}");
				}
			}
		}

		private static void TryRefreshEquippedState()
		{
			try
			{
				ToolItemManager.RefreshEquippedState();
				ToolItemManager.SendEquippedChangedEvent(true);
			}
			catch (Exception ex)
			{
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogWarning((object)("[WhiteSlotInstaller] RefreshEquippedState/SendEquippedChangedEvent failed: " + ex.Message));
				}
			}
		}

		private static SlotInfo MakeSlot(float x, float y)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			return new SlotInfo
			{
				Type = WhiteType.Value,
				Position = new Vector2(x, y),
				AttackBinding = (AttackToolBinding)0,
				IsLocked = false
			};
		}

		private static void SanitizeWhiteSlotDuplicates(List<SlotData> dataSlots, SlotInfo[] slots, ToolItemType whiteType)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < slots.Length && i < dataSlots.Count; i++)
			{
				if (slots[i].Type == whiteType)
				{
					string text = dataSlots[i].EquippedTool ?? "";
					if (text.Length != 0 && !hashSet.Add(text))
					{
						SlotData value = dataSlots[i];
						value.EquippedTool = "";
						dataSlots[i] = value;
					}
				}
			}
		}

		private static SlotInfo[] RecomputeNavigation(SlotInfo[] slots)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < slots.Length; i++)
			{
				Vector2 position = slots[i].Position;
				slots[i].NavLeftIndex = NearestInDirection(slots, i, position, Direction.Left);
				slots[i].NavRightIndex = NearestInDirection(slots, i, position, Direction.Right);
				slots[i].NavUpIndex = NearestInDirection(slots, i, position, Direction.Up);
				slots[i].NavDownIndex = NearestInDirection(slots, i, position, Direction.Down);
			}
			return slots;
		}

		private static int NearestInDirection(SlotInfo[] slots, int self, Vector2 current, Direction direction)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			int result = -1;
			float num = float.MaxValue;
			for (int i = 0; i < slots.Length; i++)
			{
				if (i == self)
				{
					continue;
				}
				Vector2 position = slots[i].Position;
				if (GetDirection(current, position) == direction)
				{
					float num2 = Vector2.Distance(current, position);
					if (num2 < num)
					{
						num = num2;
						result = i;
					}
				}
			}
			return result;
		}

		private static Direction GetDirection(Vector2 from, Vector2 to)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = from - to;
			if (val.x > 0f && val.x >= Math.Abs(val.y))
			{
				return Direction.Left;
			}
			if (val.x < 0f && 0f - val.x >= Math.Abs(val.y))
			{
				return Direction.Right;
			}
			if (val.y > 0f && val.y >= Math.Abs(val.x))
			{
				return Direction.Down;
			}
			if (val.y < 0f && 0f - val.y >= Math.Abs(val.x))
			{
				return Direction.Up;
			}
			return Direction.None;
		}
	}
	public static class WhiteSlotToolFilterPatch
	{
		private static ManualLogSource? _log;

		private static FieldRef<InventoryToolCrestSlot, InventoryItemToolManager>? _managerRef;

		private static FieldRef<InventoryItemToolManager, InventoryItemGrid>? _toolListRef;

		private static Func<InventoryItemToolManager, InventoryToolCrestSlot>? _selectedSlotGetter;

		private static Action<InventoryItemToolManager, InventoryToolCrestSlot>? _selectedSlotSetter;

		private static Func<InventoryItemToolManager, EquipStates>? _equipStateGetter;

		private static Action<InventoryItemToolManager, EquipStates>? _equipStateSetter;

		private static Func<InventoryItemToolManager, ToolItem>? _pickedUpToolGetter;

		private static Action<InventoryItemToolManager, ToolItem>? _pickedUpToolSetter;

		private static Func<InventoryItemToolManager, InventoryItemTool>? _hoveringToolGetter;

		private static FieldRef<InventoryItemTool, SpriteRenderer>? _toolItemIconRef;

		private static FieldRef<InventoryItemTool, InventoryItemToolManager>? _toolManagerRef;

		private static FieldInfo? _listSectionHeadersField;

		private static PropertyInfo? _headerColorProp;

		private static FieldRef<InventoryToolCrestSlot, SlotInfo>? _slotInfoRef;

		private static bool _warned;

		public static ToolItemType? WhiteType { get; set; }

		public static Func<bool>? IsCompassWhiteActive { get; set; }

		public static void Configure(ManualLogSource log)
		{
			_log = log;
			try
			{
				_managerRef = AccessTools.FieldRefAccess<InventoryToolCrestSlot, InventoryItemToolManager>("manager");
				_toolListRef = AccessTools.FieldRefAccess<InventoryItemToolManager, InventoryItemGrid>("toolList");
				PropertyInfo propertyInfo = AccessTools.Property(typeof(InventoryItemToolManager), "SelectedSlot");
				if (propertyInfo != null)
				{
					_selectedSlotGetter = (Func<InventoryItemToolManager, InventoryToolCrestSlot>)propertyInfo.GetGetMethod(nonPublic: true).CreateDelegate(typeof(Func<InventoryItemToolManager, InventoryToolCrestSlot>));
					_selectedSlotSetter = (Action<InventoryItemToolManager, InventoryToolCrestSlot>)propertyInfo.GetSetMethod(nonPublic: true).CreateDelegate(typeof(Action<InventoryItemToolManager, InventoryToolCrestSlot>));
				}
				PropertyInfo propertyInfo2 = AccessTools.Property(typeof(InventoryItemToolManager), "EquipState");
				if (propertyInfo2 != null)
				{
					_equipStateGetter = (Func<InventoryItemToolManager, EquipStates>)propertyInfo2.GetGetMethod(nonPublic: true).CreateDelegate(typeof(Func<InventoryItemToolManager, EquipStates>));
					_equipStateSetter = (Action<InventoryItemToolManager, EquipStates>)propertyInfo2.GetSetMethod(nonPublic: true).CreateDelegate(typeof(Action<InventoryItemToolManager, EquipStates>));
				}
				PropertyInfo propertyInfo3 = AccessTools.Property(typeof(InventoryItemToolManager), "PickedUpTool");
				_pickedUpToolGetter = ((propertyInfo3 == null) ? null : ((Func<InventoryItemToolManager, ToolItem>)propertyInfo3.GetGetMethod(nonPublic: true).CreateDelegate(typeof(Func<InventoryItemToolManager, ToolItem>))));
				_pickedUpToolSetter = ((propertyInfo3 == null) ? null : ((Action<InventoryItemToolManager, ToolItem>)propertyInfo3.GetSetMethod(nonPublic: true).CreateDelegate(typeof(Action<InventoryItemToolManager, ToolItem>))));
				PropertyInfo propertyInfo4 = AccessTools.Property(typeof(InventoryItemToolManager), "HoveringTool");
				_hoveringToolGetter = ((propertyInfo4 == null) ? null : ((Func<InventoryItemToolManager, InventoryItemTool>)propertyInfo4.GetGetMethod(nonPublic: true).CreateDelegate(typeof(Func<InventoryItemToolManager, InventoryItemTool>))));
				_toolItemIconRef = AccessTools.FieldRefAccess<InventoryItemTool, SpriteRenderer>("itemIcon");
				_toolManagerRef = AccessTools.FieldRefAccess<InventoryItemTool, InventoryItemToolManager>("manager");
				_listSectionHeadersField = AccessTools.Field(typeof(InventoryItemToolManager), "listSectionHeaders");
				_headerColorProp = _listSectionHeadersField?.FieldType.GetElementType()?.GetProperty("Color");
				_slotInfoRef = AccessTools.FieldRefAccess<InventoryToolCrestSlot, SlotInfo>("slotInfo");
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
			}
		}

		public static void TypePostfix(InventoryToolCrestSlot __instance, ref ToolItemType __result)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Invalid comparison between Unknown and I4
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected I4, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected I4, but got Unknown
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected I4, but got Unknown
			if (!WhiteType.HasValue)
			{
				return;
			}
			try
			{
				bool flag = IsCompassWhiteActive?.Invoke() ?? false;
				FieldRef<InventoryToolCrestSlot, InventoryItemToolManager> managerRef = _managerRef;
				if (managerRef == null)
				{
					return;
				}
				InventoryItemToolManager val = managerRef.Invoke(__instance);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				ToolItem val2 = _pickedUpToolGetter?.Invoke(val);
				if ((Object)(object)val2 == (Object)null && (int)val.EquipState != 2)
				{
					InventoryItemTool val3 = _hoveringToolGetter?.Invoke(val);
					if (val3 != null)
					{
						val2 = ((InventoryItemToolBase)val3).ItemData;
					}
				}
				if (!((Object)(object)val2 == (Object)null))
				{
					ToolItemType val4 = SlotType(__instance);
					if (val2.Type == WhiteType.Value && (int)val4 != 0)
					{
						__result = (ToolItemType)(int)val2.Type;
					}
					else if (val4 == WhiteType.Value && WhiteSlotPlacementRules.IsToolAllowedInSlot(val4, val2.Type, WhiteType.Value))
					{
						__result = (ToolItemType)(int)val2.Type;
					}
					else if (flag && IsCrossColorPair(val4, val2.Type))
					{
						__result = (ToolItemType)(int)val2.Type;
					}
				}
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
			}
		}

		public static void CrestHasSlotPostfix(ToolItemType type, ref bool __result)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Invalid comparison between Unknown and I4
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Invalid comparison between Unknown and I4
			if (__result || !WhiteType.HasValue)
			{
				return;
			}
			try
			{
				PlayerData instance = PlayerData.instance;
				if (instance == null || string.IsNullOrEmpty(instance.CurrentCrestID))
				{
					return;
				}
				ToolCrest crestByName = ToolItemManager.GetCrestByName(instance.CurrentCrestID);
				if ((Object)(object)crestByName == (Object)null || crestByName.Slots == null)
				{
					return;
				}
				if (type == WhiteType.Value)
				{
					__result = crestByName.Slots.Any((SlotInfo s) => (int)s.Type == 1 || (int)s.Type == 2 || s.Type == WhiteType.Value);
					return;
				}
				Func<bool>? isCompassWhiteActive = IsCompassWhiteActive;
				if (isCompassWhiteActive != null && isCompassWhiteActive() && ((int)type == 1 || (int)type == 2) && crestByName.Slots.Any((SlotInfo s) => (int)s.Type == 1 || (int)s.Type == 2))
				{
					__result = true;
				}
				else if (IsAllowedInWhiteSlot(type) && crestByName.Slots.Any((SlotInfo s) => s.Type == WhiteType.Value))
				{
					__result = true;
				}
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
			}
		}

		public static bool StartSelectionPrefix(InventoryItemToolManager __instance, InventoryToolCrestSlot slot)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (!WhiteType.HasValue || (Object)(object)slot == (Object)null || !IsCustomSlot(slot))
			{
				return true;
			}
			try
			{
				if (_selectedSlotGetter == null || _selectedSlotSetter == null || _equipStateGetter == null || _equipStateSetter == null)
				{
					return true;
				}
				FieldRef<InventoryItemToolManager, InventoryItemGrid> toolListRef = _toolListRef;
				if (toolListRef == null)
				{
					return false;
				}
				InventoryItemGrid val = toolListRef.Invoke(__instance);
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				ToolItemType slotType = SlotType(slot);
				List<InventoryItemTool> listItems = val.GetListItems<InventoryItemTool>((Func<InventoryItemTool, bool>)((InventoryItemTool toolItem) => WhiteSlotPlacementRules.IsToolAllowedInSlot(slotType, toolItem.ToolType, WhiteType.Value)));
				List<InventoryItemTool> list = listItems.Where((InventoryItemTool toolItem) => !InventoryItemToolManager.IsToolEquipped(((InventoryItemToolBase)toolItem).ItemData)).ToList();
				InventoryItemTool val2 = ((list.Count > 0) ? list[0] : ((listItems.Count > 0) ? listItems[0] : null));
				if ((Object)(object)val2 == (Object)null)
				{
					return false;
				}
				_selectedSlotSetter(__instance, slot);
				_equipStateSetter(__instance, (EquipStates)2);
				((InventoryItemManager)__instance).PlayMoveSound();
				((InventoryItemManager)__instance).SetSelected((InventoryItemSelectable)(object)val2, (SelectionDirection?)null, false);
				__instance.RefreshTools();
				return false;
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
				return true;
			}
		}

		public static bool EndSelectionPrefix(InventoryItemToolManager __instance, InventoryItemTool tool)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			InventoryToolCrestSlot selectedSlot = __instance.SelectedSlot;
			if (!WhiteType.HasValue || (Object)(object)selectedSlot == (Object)null || !IsCustomSlot(selectedSlot))
			{
				return true;
			}
			try
			{
				if (_selectedSlotSetter == null || _equipStateSetter == null)
				{
					return true;
				}
				ToolItemType slotType = SlotType(selectedSlot);
				if ((Object)(object)tool == (Object)null || (Object)(object)((InventoryItemToolBase)tool).ItemData == (Object)null || !WhiteSlotPlacementRules.IsToolAllowedInSlot(slotType, tool.ToolType, WhiteType.Value))
				{
					return true;
				}
				selectedSlot.SetEquipped(((InventoryItemToolBase)tool).ItemData, true, true);
				try
				{
					ToolItemManager.RefreshEquippedState();
				}
				catch (Exception ex)
				{
					WarnOnce(ex);
				}
				try
				{
					ToolItemManager.SendEquippedChangedEvent(true);
				}
				catch (Exception ex2)
				{
					WarnOnce(ex2);
				}
				((InventoryItemManager)__instance).PlayMoveSound();
				((InventoryItemManager)__instance).SetSelected((InventoryItemSelectable)(object)selectedSlot, (SelectionDirection?)null, false);
				_selectedSlotSetter?.Invoke(__instance, null);
				_equipStateSetter?.Invoke(__instance, (EquipStates)0);
				__instance.RefreshTools();
				return false;
			}
			catch (Exception ex3)
			{
				WarnOnce(ex3);
				return true;
			}
		}

		public static void IsSlotInvalidPostfix(ToolItemType type, InventoryToolCrestSlot nextSlot, ref bool __result)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!__result || !WhiteType.HasValue || (Object)(object)nextSlot == (Object)null || !IsCustomSlot(nextSlot) || !WhiteSlotPlacementRules.IsToolAllowedInSlot(SlotType(nextSlot), type, WhiteType.Value))
			{
				return;
			}
			try
			{
				FieldRef<InventoryToolCrestSlot, InventoryItemToolManager> managerRef = _managerRef;
				InventoryItemToolManager val = ((managerRef == null) ? null : managerRef.Invoke(nextSlot));
				__result = nextSlot.IsLocked && ((Object)(object)val == (Object)null || !val.CanUnlockSlot);
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
			}
		}

		public static void RefreshToolsPostfix(InventoryItemToolManager __instance)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			if (!WhiteType.HasValue || (Object)(object)__instance.SelectedSlot == (Object)null || !IsCustomSlot(__instance.SelectedSlot) || _listSectionHeadersField == null || _headerColorProp == null || !(_listSectionHeadersField.GetValue(__instance) is Array array))
			{
				return;
			}
			ToolItemType slotType = SlotType(__instance.SelectedSlot);
			for (int i = 0; i < array.Length; i++)
			{
				bool flag = WhiteSlotPlacementRules.IsToolAllowedInSlot(slotType, (ToolItemType)i, WhiteType.Value);
				object value = array.GetValue(i);
				if (value != null)
				{
					Color val = (Color)_headerColorProp.GetValue(value);
					float num = (flag ? 1f : 0.5f);
					if (!Mathf.Approximately(val.a, num))
					{
						val.a = num;
						_headerColorProp.SetValue(value, val);
					}
				}
			}
		}

		public static void UpdateEquippedDisplayPostfix(InventoryItemTool __instance)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			FieldRef<InventoryItemTool, InventoryItemToolManager> toolManagerRef = _toolManagerRef;
			InventoryItemToolManager val = ((toolManagerRef == null) ? null : toolManagerRef.Invoke(__instance));
			if (WhiteType.HasValue && !((Object)(object)((val != null) ? val.SelectedSlot : null) == (Object)null) && IsCustomSlot(val.SelectedSlot) && WhiteSlotPlacementRules.IsToolAllowedInSlot(SlotType(val.SelectedSlot), __instance.ToolType, WhiteType.Value))
			{
				FieldRef<InventoryItemTool, SpriteRenderer> toolItemIconRef = _toolItemIconRef;
				SpriteRenderer val2 = ((toolItemIconRef == null) ? null : toolItemIconRef.Invoke(__instance));
				if ((Object)(object)val2 != (Object)null)
				{
					val2.color = Color.white;
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPatch(typeof(InventoryItemSelectableDirectional), "GetNextSelectable", new Type[] { typeof(SelectionDirection) })]
		private static InventoryItemSelectable BaseGetNextSelectable(InventoryItemTool instance, SelectionDirection direction)
		{
			return null;
		}

		public static void ToolGetNextSelectablePostfix(InventoryItemTool __instance, SelectionDirection direction, ref InventoryItemSelectable __result)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Invalid comparison between Unknown and I4
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			FieldRef<InventoryItemTool, InventoryItemToolManager> toolManagerRef = _toolManagerRef;
			InventoryItemToolManager val = ((toolManagerRef == null) ? null : toolManagerRef.Invoke(__instance));
			if (WhiteType.HasValue && !((Object)(object)((val != null) ? val.SelectedSlot : null) == (Object)null) && IsCustomSlot(val.SelectedSlot) && (int)val.EquipState == 2)
			{
				InventoryItemSelectable val2 = BaseGetNextSelectable(__instance, direction);
				InventoryItemTool val3 = (InventoryItemTool)(object)((val2 is InventoryItemTool) ? val2 : null);
				ToolItemType slotType = SlotType(val.SelectedSlot);
				__result = (InventoryItemSelectable)(((Object)(object)val3 == (Object)null || WhiteSlotPlacementRules.IsToolAllowedInSlot(slotType, val3.ToolType, WhiteType.Value)) ? ((object)val2) : ((object)__instance));
			}
		}

		public static bool PlaceToolPrefix(InventoryItemToolManager __instance, InventoryToolCrestSlot slot, bool isManual)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (!WhiteType.HasValue || (Object)(object)slot == (Object)null)
			{
				return true;
			}
			try
			{
				ToolItem val = _pickedUpToolGetter?.Invoke(__instance);
				if ((Object)(object)val == (Object)null || val.Type != WhiteType.Value)
				{
					return true;
				}
				if (!IsRedSlot(slot))
				{
					return true;
				}
				_pickedUpToolSetter?.Invoke(__instance, null);
				_equipStateSetter?.Invoke(__instance, (EquipStates)0);
				((InventoryItemManager)__instance).PlayMoveSound();
				return false;
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
				return true;
			}
		}

		private static bool IsAllowedInWhiteSlot(ToolItemType type)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (WhiteType.HasValue)
			{
				return WhiteSlotPlacementRules.IsToolAllowedInSlot(WhiteType.Value, type, WhiteType.Value);
			}
			return false;
		}

		private static bool TryGetSlotType(InventoryToolCrestSlot? slot, out ToolItemType type)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected I4, but got Unknown
			type = (ToolItemType)0;
			if ((Object)(object)slot == (Object)null || !WhiteType.HasValue)
			{
				return false;
			}
			FieldRef<InventoryToolCrestSlot, SlotInfo> slotInfoRef = _slotInfoRef;
			if (slotInfoRef == null)
			{
				return false;
			}
			try
			{
				type = (ToolItemType)(int)slotInfoRef.Invoke(slot).Type;
				return true;
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
				return false;
			}
		}

		private static ToolItemType SlotType(InventoryToolCrestSlot? slot)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetSlotType(slot, out var type))
			{
				return (ToolItemType)0;
			}
			return type;
		}

		private static bool IsWhiteSlot(InventoryToolCrestSlot? slot)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (WhiteType.HasValue && TryGetSlotType(slot, out var type))
			{
				return type == WhiteType.Value;
			}
			return false;
		}

		private static bool IsCustomSlot(InventoryToolCrestSlot? slot)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0021: 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)
			if (WhiteType.HasValue && TryGetSlotType(slot, out var type))
			{
				if ((int)type != 1 && (int)type != 2)
				{
					return type == WhiteType.Value;
				}
				return true;
			}
			return false;
		}

		private static bool IsRedSlot(InventoryToolCrestSlot? slot)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			if (WhiteType.HasValue && TryGetSlotType(slot, out var type))
			{
				return (int)type == 0;
			}
			return false;
		}

		public static void SetEquippedPostfix(InventoryToolCrestSlot __instance, ToolItem toolItem, bool isManual, bool refreshTools)
		{
			if (!IsWhiteSlot(__instance) || !isManual)
			{
				return;
			}
			try
			{
				ToolItemManager.RefreshEquippedState();
				ToolItemManager.SendEquippedChangedEvent(true);
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
			}
		}

		private static bool IsCrossColorPair(ToolItemType slotType, ToolItemType toolType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			if ((int)slotType != 1 || (int)toolType != 2)
			{
				if ((int)slotType == 2)
				{
					return (int)toolType == 1;
				}
				return false;
			}
			return true;
		}

		private static void WarnOnce(Exception ex)
		{
			if (!_warned)
			{
				_warned = true;
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogWarning((object)("[WhiteSlotFilter] " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}
	}
	public static class WhiteToolTextPatch
	{
		private static readonly Dictionary<string, string> _texts = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		public static void Configure()
		{
			foreach (IoniaDescription.TextEntry entry in IoniaDescription.Entries)
			{
				_texts[entry.Sheet + "|" + entry.Key] = entry.Text;
			}
		}

		public static bool Prefix(string key, string sheetTitle, ref string __result)
		{
			if (_texts.Count == 0)
			{
				return true;
			}
			if (_texts.TryGetValue(sheetTitle + "|" + key, out string value))
			{
				__result = value;
				return false;
			}
			return true;
		}
	}
	public static class WhiteUniversalSlotSync
	{
		private static ManualLogSource? _log;

		private static bool _warned;

		public static ToolItemType? WhiteType { get; set; }

		public static void Configure(ManualLogSource log)
		{
			_log = log;
		}

		public static void Prefix(string crestId)
		{
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			if (!WhiteType.HasValue || string.IsNullOrEmpty(crestId))
			{
				return;
			}
			try
			{
				PlayerData instance = PlayerData.instance;
				if (instance == null || string.IsNullOrEmpty(instance.CurrentCrestID) || string.Equals(instance.CurrentCrestID, crestId, StringComparison.OrdinalIgnoreCase))
				{
					return;
				}
				ToolCrest current = ToolItemManager.GetCrestByName(instance.CurrentCrestID);
				ToolCrest target = ToolItemManager.GetCrestByName(crestId);
				if ((Object)(object)current == (Object)null || (Object)(object)target == (Object)null || current.Slots == null || target.Slots == null)
				{
					return;
				}
				int[] array = (from i in Enumerable.Range(0, current.Slots.Length)
					where current.Slots[i].Type == WhiteType.Value
					select i).ToArray();
				if (array.Length == 0)
				{
					return;
				}
				Data data = ((SerializableNamedList<Data, NamedData>)(object)instance.ToolEquips).GetData(current.name);
				Data data2 = ((SerializableNamedList<Data, NamedData>)(object)instance.ToolEquips).GetData(target.name);
				if (data.Slots == null || data2.Slots == null)
				{
					return;
				}
				int[] array2 = (from i in Enumerable.Range(0, target.Slots.Length)
					where target.Slots[i].Type == WhiteType.Value
					select i).ToArray();
				bool flag = false;
				int[] array3 = array2;
				foreach (int num2 in array3)
				{
					if (num2 < data2.Slots.Count)
					{
						SlotData val = data2.Slots[num2];
						if (val.EquippedTool != "")
						{
							val.EquippedTool = "";
							data2.Slots[num2] = val;
							flag = true;
						}
					}
				}
				int num3 = Math.Min(array.Length, array2.Length);
				for (int num4 = 0; num4 < num3; num4++)
				{
					int num5 = array[num4];
					int num6 = array2[num4];
					if (num5 < data.Slots.Count && num6 < data2.Slots.Count)
					{
						string equippedTool = data.Slots[num5].EquippedTool;
						SlotData val2 = data2.Slots[num6];
						if (val2.EquippedTool != equippedTool)
						{
							val2.EquippedTool = equippedTool;
							data2.Slots[num6] = val2;
							flag = true;
						}
					}
				}
				if (flag)
				{
					((SerializableNamedList<Data, NamedData>)(object)instance.ToolEquips).SetData(target.name, data2);
					ToolItemManager.RefreshEquippedState();
					ToolItemManager.SendEquippedChangedEvent(true);
					ManualLogSource? log = _log;
					if (log != null)
					{
						log.LogDebug((object)$"[WhiteUniversalSlot] synced {array.Length} white slots to '{target.name}'.");
					}
				}
			}
			catch (Exception ex)
			{
				WarnOnce(ex);
			}
		}

		private static void WarnOnce(Exception ex)
		{
			if (!_warned)
			{
				_warned = true;
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogWarning((object)("[WhiteUniversalSlot] " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}
	}
}
namespace CrestsEvolve.GameInterop.Input
{
	public static class DirectionMasks
	{
		public const int Up = 1;

		public const int Down = 2;

		public const int Left = 4;

		public const int Right = 8;
	}
	public readonly struct InputFrame
	{
		public bool MainHeld { get; }

		public bool MainPressed { get; }

		public bool MainReleased { get; }

		public int DirectionMask { get; }

		public InputFrame(bool mainHeld, bool mainPressed, bool mainReleased, int directionMask)
		{
			MainHeld = mainHeld;
			MainPressed = mainPressed;
			MainReleased = mainReleased;
			DirectionMask = directionMask;
		}
	}
	public sealed class NativeInputAdapter
	{
		internal sealed class ActionReader
		{
			private readonly object _action;

			private readonly PropertyInfo? _isPressedProperty;

			private readonly PropertyInfo? _wasPressedProperty;

			private readonly PropertyInfo? _wasReleasedProperty;

			private readonly MethodInfo? _isPressedMethod;

			private readonly MethodInfo? _wasPressedMethod;

			private readonly MethodInfo? _wasReleasedMethod;

			public string Name { get; }

			public bool CanRead
			{
				get
				{
					if (!(_isPressedProperty != null))
					{
						return _isPressedMethod != null;
					}
					return true;
				}
			}

			public ActionReader(string name, object action)
			{
				Name = name;
				_action = action;
				Type type = action.GetType();
				_isPressedProperty = ReflectionLookup.FindBoolProperty(type, "IsPressed", "isPressed");
				_wasPressedProperty = ReflectionLookup.FindBoolProperty(type, "WasPressed", "wasPressed");
				_wasReleasedProperty = ReflectionLookup.FindBoolProperty(type, "WasReleased", "wasReleased");
				_isPressedMethod = ReflectionLookup.FindBoolMethod(type, "IsPressed", "get_IsPressed");
				_wasPressedMethod = ReflectionLookup.FindBoolMethod(type, "WasPressed", "get_WasPressed");
				_wasReleasedMethod = ReflectionLookup.FindBoolMethod(type, "WasReleased", "get_WasReleased");
			}

			public bool IsPressed()
			{
				return Read(_isPressedProperty, _isPressedMethod);
			}

			public bool WasPressed()
			{
				return Read(_wasPressedProperty, _wasPressedMethod);
			}

			public bool WasReleased()
			{
				return Read(_wasReleasedProperty, _wasReleasedMethod);
			}

			private bool Read(PropertyInfo? property, MethodInfo? method)
			{
				try
				{
					if (property != null)
					{
						return (bool)property.GetValue(_action, null);
					}
					if (method != null)
					{
						return (bool)method.Invoke(_action, null);
					}
				}
				catch
				{
				}
				return false;
			}
		}

		private sealed class VectorReader
		{
			private readonly object _action;

			private readonly PropertyInfo? _property;

			private readonly FieldInfo? _field;

			private readonly MethodInfo? _method;

			public string Name { get; }

			public bool CanRead
			{
				get
				{
					if (!(_property != null) && !(_field != null))
					{
						return _method != null;
					}
					return true;
				}
			}

			public VectorReader(string name, object action)
			{
				Name = name;
				_action = action;
				Type type = action.GetType();
				_property = ReflectionLookup.FindVectorProperty(type, "Vector", "Value", "RawValue", "Direction");
				_field = ReflectionLookup.FindVectorField(type, "Vector", "Value", "RawValue", "Direction");
				_method = ReflectionLookup.FindVectorMethod(type, "ReadValue", "GetValue", "GetVector");
			}

			public Vector2 Read()
			{
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					object obj = _property?.GetValue(_action, null) ?? _field?.GetValue(_action) ?? _method?.Invoke(_action, null);
					if (obj is Vector2)
					{
						return (Vector2)obj;
					}
				}
				catch
				{
				}
				return Vector2.zero;
			}
		}

		private static readonly string[] UpCandidates = new string[4] { "up", "moveUp", "verticalUp", "menuUp" };

		private static readonly string[] DownCandidates = new string[4] { "down", "moveDown", "verticalDown", "menuDown" };

		private static readonly string[] LeftCandidates = new string[4] { "left", "moveLeft", "horizontalLeft", "menuLeft" };

		private static readonly string[] RightCandidates = new string[4] { "right", "moveRight", "horizontalRight", "menuRight" };

		private static readonly string[] MoveVectorCandidates = new string[4] { "moveVector", "movement", "move", "directionVector" };

		private readonly ManualLogSource _log;

		private object? _actionSet;

		private ActionReader? _main;

		private ActionReader? _up;

		private ActionReader? _down;

		private ActionReader? _left;

		private ActionReader? _right;

		private VectorReader? _moveVector;

		private bool _warnedNotReady;

		public bool IsReady
		{
			get
			{
				if (_actionSet != null && _main != null)
				{
					if (_up == null || _down == null || _left == null || _right == null)
					{
						return _moveVector != null;
					}
					return true;
				}
				return false;
			}
		}

		public NativeInputAdapter(ManualLogSource log)
		{
			_log = log;
		}

		public void Reset()
		{
			_actionSet = null;
			_main = (_up = (_down = (_left = (_right = null))));
			_moveVector = null;
			_warnedNotReady = false;
		}

		public void Bind(HeroController hero, IReadOnlyList<string> mainCandidates)
		{
			Reset();
			_actionSet = ResolveActionSet(hero);
			if (_actionSet == null)
			{
				WarnOnce("Unable to resolve the game's inputActions object. Quick switching is disabled; no fixed-key fallback will be used.");
				return;
			}
			_main = FindAction(_actionSet, mainCandidates);
			_up = FindAction(_actionSet, UpCandidates);
			_down = FindAction(_actionSet, DownCandidates);
			_left = FindAction(_actionSet, LeftCandidates);
			_right = FindAction(_actionSet, RightCandidates);
			_moveVector = FindVector(_actionSet, MoveVectorCandidates);
			if (!IsReady)
			{
				string text = string.Join(", ", ReflectionLookup.GetMemberNames(_actionSet.GetType()));
				WarnOnce("Native input actions were found, but one or more required actions could not be mapped. Available members: " + text);
				return;
			}
			_log.LogInfo((object)("[CrestQuickSwitch] Native input bound: main=" + _main?.Name + "; up=" + _up?.Name + "; down=" + _down?.Name + "; left=" + _left?.Name + "; right=" + _right?.Name + "; vector=" + _moveVector?.Name));
		}

		public void RefreshIfActionSetChanged(HeroController hero, IReadOnlyList<string> mainCandidates)
		{
			object obj = ResolveActionSet(hero);
			if (obj == null)
			{
				if (_actionSet != null)
				{
					Reset();
				}
			}
			else if (obj != _actionSet)
			{
				Bind(hero, mainCandidates);
			}
		}

		public InputFrame ReadFrame()
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (!IsReady || _main == null)
			{
				return default(InputFrame);
			}
			int num = 0;
			ActionReader? up = _up;
			if (up != null && up.IsPressed())
			{
				num |= 1;
			}
			ActionReader? down = _down;
			if (down != null && down.IsPressed())
			{
				num |= 2;
			}
			ActionReader? left = _left;
			if (left != null && left.IsPressed())
			{
				num |= 4;
			}
			ActionReader? right = _right;
			if (right != null && right.IsPressed())
			{
				num |= 8;
			}
			if (num == 0 && _moveVector != null)
			{
				Vector2 val = _moveVector.Read();
				if (val.y > 0.45f)
				{
					num |= 1;
				}
				if (val.y < -0.45f)
				{
					num |= 2;
				}
				if (val.x < -0.45f)
				{
					num |= 4;
				}
				if (val.x > 0.45f)
				{
					num |= 8;
				}
			}
			return new InputFrame(_main.IsPressed(), _main.WasPressed(), _main.WasReleased(), num);
		}

		private object? ResolveActionSet(HeroController hero)
		{
			object obj = ReflectionLookup.ReadMember(hero, "inputHandler", "InputHandler");
			if (obj == null)
			{
				obj = ReflectionLookup.ReadStaticMember(AccessTools.TypeByName("InputHandler"), "Instance", "instance");
			}
			if (obj != null)
			{
				return ReflectionLookup.ReadMember(obj, "inputActions", "InputActions", "actions", "Actions");
			}
			return null;
		}

		internal static ActionReader? FindAction(object actionSet, IEnumerable<string> candidates)
		{
			foreach (string candidate in candidates)
			{
				object obj = ReflectionLookup.ReadMember(actionSet, candidate);
				if (obj != null)
				{
					ActionReader actionReader = new ActionReader(candidate, obj);
					if (actionReader.CanRead)
					{
						return actionReader;
					}
				}
			}
			return null;
		}

		private static VectorReader? FindVector(object actionSet, IEnumerable<string> candidates)
		{
			foreach (string candidate in candidates)
			{
				object obj = ReflectionLookup.ReadMember(actionSet, candidate);
				if (obj != null)
				{
					VectorReader vectorReader = new VectorReader(candidate, obj);
					if (vectorReader.CanRead)
					{
						return vectorReader;
					}
				}
			}
			return null;
		}

		private void WarnOnce(string message)
		{
			if (!_warnedNotReady)
			{
				_warnedNotReady = true;
				_log.LogWarning((object)("[CrestQuickSwitch] " + message));
			}
		}
	}
	public sealed class SkillUseSignalSource : MonoBehaviour
	{
		private ManualLogSource? _log;

		private GameEventHub? _events;

		private string[] _candidates = new string[1] { "cast" };

		private object? _actionSet;

		private NativeInputAdapter.ActionReader? _skill;

		private bool _disabled;

		private bool _warned;

		public void Initialize(ManualLogSource log, GameEventHub events, string candidates)
		{
			_log = log;
			_events = events;
			_candidates = (from candidate in (candidates ?? "cast").Split(new char[3] { ',', ';', '|' }, StringSplitOptions.RemoveEmptyEntries)
				select candidate.Trim() into candidate
				where candidate.Length > 0
				select candidate).ToArray();
		}

		private void Update()
		{
			if (_disabled || _events == null)
			{
				return;
			}
			HeroController instance = HeroController.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				if (_actionSet == null)
				{
					Bind(instance);
				}
				if (_skill != null && _skill.WasPressed())
				{
					_events.Publish(new SkillUseEvent("input.skill", _skill.Name));
				}
			}
		}

		private void Bind(HeroController hero)
		{
			object obj = ReflectionLookup.ReadMember(hero, "inputHandler", "InputHandler");
			if (obj == null)
			{
				obj = ReflectionLookup.ReadStaticMember(AccessTools.TypeByName("InputHandler"), "Instance", "instance");
			}
			_actionSet = ((obj == null) ? null : ReflectionLookup.ReadMember(obj, "inputActions", "InputActions", "actions", "Actions"));
			if (_actionSet == null)
			{
				WarnOnce("Unable to resolve inputActions for the skill signal. Fire-blade driver stays disabled.");
				_disabled = true;
				return;
			}
			_skill = NativeInputAdapter.FindAction(_actionSet, _candidates);
			if (_skill != null)
			{
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogInfo((object)("[SkillSignal][probe] bound action '" + _skill.Name + "'"));
				}
			}
			else
			{
				WarnOnce("Skill action candidates not found (" + string.Join(", ", _candidates) + "). " + $"Available members: {ReflectionLookup.GetMemberNames(_actionSet.GetType())}");
				_disabled = true;
			}
		}

		private void WarnOnce(string message)
		{
			if (!_warned)
			{
				_warned = true;
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogWarning((object)("[SkillSignal][probe] " + message));
				}
			}
		}
	}
}
namespace CrestsEvolve.GameInterop.CrestSwitching
{
	public sealed class HeroReflectionCache
	{
		private readonly ManualLogSource _log;

		private FieldInfo? _cState;

		private FieldInfo? _attacking;

		private FieldInfo? _upAttacking;

		private FieldInfo? _downAttacking;

		private FieldInfo? _nailCharging;

		private FieldInfo? _dashing;

		private FieldInfo? _backDashing;

		private FieldInfo? _canControl;

		private FieldInfo? _isDashStabBouncing;

		private FieldInfo? _acceptingInput;

		private FieldInfo? _controlRelinquished;

		private MethodInfo? _addInvincibleTime;

		private FieldInfo? _invincibleTimer;

		private MethodInfo? _resetAttacksDash;

		private MethodInfo? _resetAttacks;

		private readonly List<MethodInfo> _dashCancelMethods = new List<MethodInfo>();

		public HeroReflectionCache(ManualLogSource log)
		{
			_log = log;
		}

		public void Initialize(HeroController hero)
		{
			Type type = ((object)hero).GetType();
			_cState = ReflectionLookup.FindField(type, "cState", "CState", "heroState");
			Type type2 = _cState?.FieldType;
			if (type2 != null)
			{
				_attacking = ReflectionLookup.FindField(type2, "attacking");
				_upAttacking = ReflectionLookup.FindField(type2, "upAttacking");
				_downAttacking = ReflectionLookup.FindField(type2, "downAttacking");
				_nailCharging = ReflectionLookup.FindField(type2, "nailCharging", "chargingAttack");
				_dashing = ReflectionLookup.FindField(type2, "dashing", "isDashing");
				_backDashing = ReflectionLookup.FindField(type2, "backDashing", "isBackDashing");
				_canControl = ReflectionLookup.FindField(type2, "canControl");
			}
			_isDashStabBouncing = ReflectionLookup.FindField(type, "isDashStabBouncing");
			_acceptingInput = ReflectionLookup.FindField(type, "acceptingInput");
			_controlRelinquished = ReflectionLookup.FindField(type, "controlRelinquished");
			_addInvincibleTime = ReflectionLookup.FindMethod(type, "AddInvincibleTime", typeof(float));
			_invincibleTimer = ReflectionLookup.FindField(type, "invincibleTimer");
			_resetAttacksDash = ReflectionLookup.FindMethod(type, "ResetAttacksDash");
			_resetAttacks = ReflectionLookup.FindMethod(type, "ResetAttacks", typeof(bool));
			_dashCancelMethods.Clear();
			string[] array = new string[5] { "CancelDash", "StopDash", "EndDash", "DashEnd", "ResetDash" };
			foreach (string name in array)
			{
				MethodInfo methodInfo = ReflectionLookup.FindMethod(type, name);
				if (methodInfo != null && !_dashCancelMethods.Contains(methodInfo))
				{
					_dashCancelMethods.Add(methodInfo);
				}
			}
		}

		public bool IsAttackOrChargeActive(HeroController hero)
		{
			object obj = _cState?.GetValue(hero);
			if (obj != null)
			{
				if (!ReadBool(obj, _attacking) && !ReadBool(obj, _upAttacking) && !ReadBool(obj, _downAttacking))
				{
					return ReadBool(obj, _nailCharging);
				}
				return true;
			}
			return false;
		}

		public bool IsDashLikeActive(HeroController hero)
		{
			object obj = _cState?.GetValue(hero);
			if (obj == null || (!ReadBool(obj, _dashing) && !ReadBool(obj, _backDashing)))
			{
				return ReadBool(hero, _isDashStabBouncing);
			}
			return true;
		}

		public bool HasControl(HeroController hero)
		{
			try
			{
				object obj = _cState?.GetValue(hero);
				bool flag = true;
				if (obj != null && _canControl != null)
				{
					flag &= ReadBool(obj, _canControl);
				}
				if (_acceptingInput != null)
				{
					flag &= ReadBool(hero, _acceptingInput);
				}
				if (_controlRelinquished != null)
				{
					flag &= !ReadBool(hero, _controlRelinquished);
				}
				return flag;
			}
			catch
			{
				return false;
			}
		}

		public void NormalizeDashExit(HeroController hero, bool zeroHorizontalVelocity)
		{
			try
			{
				_resetAttacksDash?.Invoke(hero, null);
			}
			catch
			{
			}
			try
			{
				_resetAttacks?.Invoke(hero, new object[1] { true });
			}
			catch
			{
			}
			foreach (MethodInfo dashCancelMethod in _dashCancelMethods)
			{
				try
				{
					dashCancelMethod.Invoke(hero, null);
				}
				catch
				{
				}
			}
			object obj4 = null;
			try
			{
				obj4 = _cState?.GetValue(hero);
			}
			catch
			{
			}
			if (obj4 != null)
			{
				WriteBool(obj4, _dashing, value: false);
				WriteBool(obj4, _backDashing, value: false);
			}
			WriteBool(hero, _isDashStabBouncing, value: false);
			if (zeroHorizontalVelocity)
			{
				ZeroHorizontalVelocity(hero);
			}
		}

		public void ApplyInvincibility(HeroController hero, float seconds)
		{
			if (seconds <= 0f)
			{
				return;
			}
			try
			{
				if (_addInvincibleTime != null)
				{
					_addInvincibleTime.Invoke(hero, new object[1] { seconds });
				}
				else if (_invincibleTimer != null)
				{
					float num = Convert.ToSingle(_invincibleTimer.GetValue(hero));
					_invincibleTimer.SetValue(hero, Mathf.Max(num, seconds));
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CrestQuickSwitch] Failed to apply invulnerability: " + ex.Message));
			}
		}

		private static void ZeroHorizontalVelocity(HeroController hero)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Rigidbody2D component = ((Component)hero).GetComponent<Rigidbody2D>();
				if (!((Object)(object)component == (Object)null))
				{
					Type type = ((object)component).GetType();
					PropertyInfo propertyInfo = AccessTools.Property(type, "linearVelocity") ?? AccessTools.Property(type, "velocity");
					if (propertyInfo != null && propertyInfo.CanRead && propertyInfo.CanWrite && propertyInfo.GetValue(component, null) is Vector2 val)
					{
						propertyInfo.SetValue(component, (object)new Vector2(0f, val.y), null);
					}
				}
			}
			catch
			{
			}
		}

		private static bool ReadBool(object target, FieldInfo? field)
		{
			try
			{
				bool flag = default(bool);
				int num;
				if (field != null)
				{
					object value = field.GetValue(target);
					if (value is bool)
					{
						flag = (bool)value;
						num = 1;
					}
					else
					{
						num = 0;
					}
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch
			{
				return false;
			}
		}

		private static void WriteBool(object target, FieldInfo? field, bool value)
		{
			try
			{
				if (field != null && field.FieldType == typeof(bool))
				{
					field.SetValue(target, value);
				}
			}
			catch
			{
			}
		}
	}
}
namespace CrestsEvolve.GameInterop.Binding
{
	public sealed class DynamicPatchResolver
	{
		private readonly ManualLogSource _log;

		private readonly GameBindingConfig _config;

		private readonly List<BindingReportEntry> _report = new List<BindingReportEntry>();

		public DynamicPatchResolver(ManualLogSource log, GameBindingConfig config)
		{
			_log = log;
			_config = config;
		}

		public MethodBase? Resolve(string bindingId)
		{
			if (!_config.Methods.TryGetValue(bindingId, out MethodBindingSpec spec))
			{
				Record(bindingId, "missing-spec", Array.Empty<string>());
				return null;
			}
			List<MethodBase> list = new List<MethodBase>();
			string[] typeCandidates = spec.TypeCandidates;
			for (int i = 0; i < typeCandidates.Length; i++)
			{
				Type type = AccessTools.TypeByName(typeCandidates[i]);
				if ((object)type == null)
				{
					continue;
				}
				string[] methodCandidates = spec.MethodCandidates;
				foreach (string methodName in methodCandidates)
				{
					IEnumerable<MethodInfo> collection = from m in type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
						where m.Name == methodName && SignatureMatches(m, spec)
						select m;
					list.AddRange(collection);
				}
			}
			list = list.Distinct().ToList();
			if (list.Count == 1)
			{
				Record(bindingId, "resolved", new string[1] { Describe(list[0]) });
				return list[0];
			}
			string text = ((list.Count == 0) ? "not-found" : "ambiguous");
			Record(bindingId, text, list.Select(Describe).ToArray());
			if (spec.Required)
			{
				_log.LogError((object)("Required binding " + bindingId + " is " + text + "."));
			}
			else
			{
				_log.LogWarning((object)("Optional binding " + bindingId + " is " + text + "."));
			}
			return null;
		}

		public FieldInfo? ResolveField(string bindingId)
		{
			if (!_config.Fields.TryGetValue(bindingId, out FieldBindingSpec value))
			{
				Record(bindingId, "missing-spec", Array.Empty<string>());
				return null;
			}
			List<FieldInfo> list = new List<FieldInfo>();
			string[] typeCandidates = value.TypeCandidates;
			for (int i = 0; i < typeCandidates.Length; i++)
			{
				Type type = AccessTools.TypeByName(typeCandidates[i]);
				if ((object)type == null)
				{
					continue;
				}
				string[] fieldCandidates = value.FieldCandidates;
				foreach (string name in fieldCandidates)
				{
					FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null)
					{
						list.Add(field);
					}
				}
			}
			list = list.Distinct().ToList();
			if (list.Count == 1)
			{
				Record(bindingId, "resolved", new string[1] { Describe(list[0]) });
				return list[0];
			}
			string text = ((list.Count == 0) ? "not-found" : "ambiguous");
			Record(bindingId, text, list.Select(Describe).ToArray());
			if (value.Required)
			{
				_log.LogError((object)("Required field binding " + bindingId + " is " + text + "."));
			}
			else
			{
				_log.LogWarning((object)("Optional field binding " + bindingId + " is " + text + "."));
			}
			return null;
		}

		public void WriteReport()
		{
			string text = Path.Combine(Paths.ConfigPath, "CrestsEvolve");
			Directory.CreateDirectory(text);
			File.WriteAllText(Path.Combine(text, "binding-report.json"), JsonConvert.SerializeObject((object)_report, (Formatting)1));
		}

		private static bool SignatureMatches(MethodInfo method, MethodBindingSpec spec)
		{
			ParameterInfo[] parameters = method.GetParameters();
			if (spec.ParameterTypeNames.Length != 0)
			{
				if (parameters.Length != spec.ParameterTypeNames.Length)
				{
					return false;
				}
				for (int i = 0; i < parameters.Length; i++)
				{
					if (parameters[i].ParameterType.FullName != spec.ParameterTypeNames[i])
					{
						return false;
					}
				}
			}
			if (spec.ReturnTypeName != null && method.ReturnType.FullName != spec.ReturnTypeName)
			{
				return false;
			}
			return true;
		}

		private void Record(string id, string status, string[] candidates)
		{
			_report.Add(new BindingReportEntry(id, status, candidates));
		}

		private static string Describe(MethodBase m)
		{
			return $"{m.DeclaringType?.FullName}::{m}";
		}

		private static string Describe(FieldInfo f)
		{
			return f.DeclaringType?.FullName + "::" + f.Name;
		}
	}
	public sealed record BindingReportEntry(string BindingId, string Status, string[] Candidates);
	public sealed class GameBindingConfig
	{
		public Dictionary<string, MethodBindingSpec> Methods { get; set; } = new Dictionary<string, MethodBindingSpec>(StringComparer.Ordinal);

		public Dictionary<string, FieldBindingSpec> Fields { get; set; } = new Dictionary<string, FieldBindingSpec>(StringComparer.Ordinal);

		public Dictionary<string, string[]> Assets { get; set; } = new Dictionary<string, string[]>(StringComparer.Ordinal);

		public static GameBindingConfig LoadOrCreate(ManualLogSource log)
		{
			string text = Path.Combine(Paths.ConfigPath, "CrestsEvolve", "game-bindings.json");
			Directory.CreateDirectory(Path.GetDirectoryName(text));
			if (!File.Exists(text))
			{
				GameBindingConfig gameBindingConfig = new GameBindingConfig();
				File.WriteAllText(text, JsonConvert.SerializeObject((object)gameBindingConfig, (Formatting)1));
				log.LogWarning((object)("Created empty binding file: " + text));
				return gameBindingConfig;
			}
			try
			{
				return JsonConvert.DeserializeObject<GameBindingConfig>(File.ReadAllText(text)) ?? new GameBindingConfig();
			}
			catch (Exception arg)
			{
				log.LogError((object)$"Failed to parse game bindings: {arg}");
				return new GameBindingConfig();
			}
		}
	}
	public sealed class MethodBindingSpec
	{
		public string[] AssemblyCandidates { get; set; } = Array.Empty<string>();

		public string[] TypeCandidates { get; set; } = Array.Empty<string>();

		public string[] MethodCandidates { get; set; } = Array.Empty<string>();

		public string[] ParameterTypeNames { get; set; } = Array.Empty<string>();

		public string? ReturnTypeName { get; set; }

		public bool Required { get; set; }
	}
	public sealed class FieldBindingSpec
	{
		public string[] AssemblyCandidates { get; set; } = Array.Empty<string>();

		public string[] TypeCandidates { get; set; } = Array.Empty<string>();

		public string[] FieldCandidates { get; set; } = Array.Empty<string>();

		public bool Required { get; set; }
	}
}
namespace CrestsEvolve.Features
{
	public static class BalanceBinder
	{
		public static BalanceOptions Bind(ConfigFile config, ManualLogSource log)
		{
			BalanceOptions balanceOptions = new BalanceOptions(HunterBalanceOptions.Defaults, BindSilkMother(config), BindSafety(config), ToolBalanceOptions.Defaults, RageBalanceOptions.Defaults);
			IReadOnlyList<string> readOnlyList = balanceOptions.Validate();
			if (readOnlyList.Count == 0)
			{
				return balanceOptions;
			}
			foreach (string item in readOnlyList)
			{
				log.LogWarning((object)("Balance config invalid: " + item));
			}
			log.LogWarning((object)"Falling back to balance defaults; fix values in F1 config and restart.");
			return BalanceOptions.Defaults;
		}

		public static HunterBalanceOptions BindHunter(ConfigFile config)
		{
			return new HunterBalanceOptions(config.Bind<bool>("Hunter", "Enabled", true, "Enable Hunter crest module (startup condition).").Value, config.Bind<double>("Hunter", "StackDurationSeconds", 10.0, "Combo stack duration in seconds (HUN-004).").Value, config.Bind<int>("Hunter", "Level2Threshold", 6, "Stacks required for level 2 (HUN-002).").Value, config.Bind<int>("Hunter", "Level3Threshold", 12, "Stacks required for level 3 (HUN-003).").Value, config.Bind<int>("Hunter", "Level2CharmOffset", 1, "Temporary charm level offset at level 2 (HUN-002).").Value, config.Bind<int>("Hunter", "Level3CharmOffset", 2, "Temporary charm level offset at level 3 (HUN-003).").Value, config.Bind<int>("Hunter", "RageMinStacks", 6, "Minimum stacks when entering rage (HUN-021).").Value, config.Bind<int>("Hunter", "SuperRageHitsPerBonus", 6, "Attacks per super-rage damage bonus (HUN-024).").Value, config.Bind<double>("Hunter", "SuperRageFlatDamagePerBonus", 5.0, "Flat damage added per super-rage bonus (HUN-024).").Value, config.Bind<double>("Hunter", "SuperRageDurationSeconds", 10.0, "Super rage duration in seconds (HUN-024).").Value, config.Bind<double>("Hunter", "DashAttackRangeMultiplier", 1.0, "Dash attack range multiplier [待实测] (HUN-005).").Value, config.Bind<bool>("Hunter", "DashAttackPierce", true, "Dash attack pierces enemies [待实测] (HUN-005).").Value, config.Bind<double>("Hunter", "DashInvulnerabilitySeconds", 0.1, "Dash attack invulnerability seconds [待实测] (HUN-005).").Value, config.Bind<double>("Hunter", "DiceCritChanceL1", 0.03, "Dice crit chance at level 1 (HUN-030).").Value, config.Bind<double>("Hunter", "DiceCritChanceL2", 0.05, "Dice crit chance at level 2 (HUN-030).").Value, config.Bind<double>("Hunter", "DiceCritChanceL3", 0.07, "Dice crit chance at level 3 (HUN-030).").Value, config.Bind<double>("Hunter", "EnhancedDiceCritBonusL1", 0.01, "Enhanced dice crit bonus at level 1 [待实测] (HUN-030).").Value, config.Bind<double>("Hunter", "EnhancedDiceCritBonusL2", 0.02, "Enhanced dice crit bonus at level 2 [待实测] (HUN-030).").Value);
		}

		private static SilkMotherBalanceOptions BindSilkMother(ConfigFile config)
		{
			return new SilkMotherBalanceOptions(config.Bind<bool>("SilkMother", "Enabled", true, "Enable Silk Mother crest module (startup condition).").Value, config.Bind<int>("SilkMother", "MaxStage", 12, "Maximum enhancement stage (MOT-006).").Value, config.Bind<int>("SilkMother", "StageCostSilk", 9, "Silk cost to enter/raise a stage (MOT-001/006).").Value, config.Bind<int>("SilkMother", "SilkPerMaskDamage", 3, "Silk consumed per mask of damage (MOT-002).").Value, config.Bind<int>("SilkMother", "SilkCapWhileEnhanced", 99, "Silk cap while enhanced (MOT-005).").Value, config.Bind<int>("SilkMother", "MinimumSilkToEnter", 9, "Minimum silk required to enter/keep enhancement (MOT-005).").Value);
		}

		public static RageBalanceOptions BindRage(ConfigFile config)
		{
			return new RageBalanceOptions(config.Bind<bool>("Rage", "Enabled", true, "Enable the shared rage/super-rage system.").Value, config.Bind<double>("Rage", "SuperRageDurationSeconds", 10.0, "Default super-rage duration in seconds (overridden by crest behaviors such as HUN-024).").Value, config.Bind<int>("Rage", "AttacksPerBonus", 6, "Default attacks per super-rage bonus tick (overridden by crest behaviors).").Value, config.Bind<bool>("Rage", "AutoSuperRageEnabled", true, "Allow automatic super rage when generic conditions are met.").Value, config.Bind<bool>("Rage", "ResetBonusOnDamage", false, "Clear accumulated super-rage bonus when damaged. Default false: hit does not clear, only timer expiry clears (HUN-024).").Value, config.Bind<double>("Rage", "WandererDamageMultiplier", 1.75, "Wanderer normal-rage damage multiplier for needle/melee damage (WAN-020).").Value, config.Bind<double>("Rage", "WitchDashDamageMultiplier", 1.0, "Witch normal-rage dash damage multiplier relative to current nail damage (WIT-020; default 1.0 = same as a normal attack) [待实测].").Value, config.Bind<double>("Rage", "WitchSawbladeCritChance", 0.1, "Witch normal-rage sawblade (Brolly Spike) crit chance (WIT-021) [待实测].").Value, config.Bind<string>("Rage", "WitchSawbladeToolId", "Brolly Spike", "Tool id whose hits may crit while Witch normal rage is active (WIT-021; E1 tool name used by ToolCatalog/blue tool patches).").Value, config.Bind<double>("Rage", "ArchitectToolDamageMultiplier", 1.75, "Architect normal-rage multiplier for all tool damage (ARC-020 phase-1 scope).").Value, config.Bind<double>("Rage", "ShamanCritChance", 0.1, "Shaman normal-rage crit chance for wave and charge-slash hits (SHA-021).").Value, config.Bind<int>("Rage", "ShamanWaveSilkPerHit", 1, "Silk gained per wave hit during Shaman normal rage (SHA-020).").Value, config.Bind<double>("Rage", "WandererSuperRageCritPerBonus", 0.02, "Wanderer super-rage crit chance gained per 6 hits (WAN-021).").Value, config.Bind<double>("Rage", "ReaperExplosionDamageMultiplier", 1.0, "Reaper super-rage crit explosion damage multiplier relative to the final crit hit damage (REA-024) [待实测].").Value, config.Bind<double>("Rage", "ReaperExplosionRadius", 3.0, "Reaper super-rage crit explosion radius in meters (REA-024) [待实测].").Value, config.Bind<int>("Rage", "WitchDashSilkPerHit", 1, "Silk restored per dash hit during Witch super rage (WIT-024, xlsx) [待实测].").Value, config.Bind<double>("Rage", "WitchSuperRageBindDamageMultiplier", 2.0, "Witch super-rage bind heal-skill damage multiplier (WIT-025, xlsx) [待实测].").Value, config.Bind<double>("Rage", "WitchSuperRageBindRangeMultiplier", 2.0, "Witch super-rage bind heal-skill range multiplier (WIT-025, xlsx) [待实测].").Value, config.Bind<int>("Rage", "ArchitectToolSilkPerHit", 1, "Silk restored per tool hit during Architect super rage (ARC-022, xlsx) [待实测].").Value, config.Bind<double>("Rage", "CursedSkillDamageMultiplier", 1.75, "Cursed-crest rage multiplier for all skill damage (CUR-020).").Value, config.Bind<double>("Rage", "CloaklessBlockChance", 0.8, "Useless-crest rage block chance on enemy hits, using the game's dice block path (USE-020).").Value, config.Bind<double>("Rage", "CloaklessCritChance", 0.8, "Useless-crest super-rage crit chance (USE-021).").Value, config.Bind<int>("Rage", "ShamanSkillCostReduction", 1, "Shaman super-rage skill silk cost reduction (SHA-022).").Value, config.Bind<int>("Rage", "HunterSilkPerHit", 1, "Extra silk per attack hit while focus threshold reached (HUN-027/028).").Value, config.Bind<int>("Rage", "HunterFocusThresholdRage", 6, "Focus meter hits required for normal-rage extra silk (HUN-027).").Value, config.Bind<int>("Rage", "HunterFocusThresholdSuperRage", 12, "Focus meter hits required for super-rage extra silk (HUN-028).").Value, config.Bind<int>("Rage", "ReaperSilkOrbPartsMultiplier", 3, "Silk parts multiplier for Reaper orb conversion (3 = 1:1 from 3:1, REA-028).").Value, config.Bind<double>("Rage", "WandererCritDamageMultiplier", 2.0, "Wanderer super-rage crit damage multiplier (WAN-024).").Value, config.Bind<double>("Rage", "WandererKnockbackMultiplier", 2.0, "Wanderer super-rage knockback multiplier (WAN-024).").Value, config.Bind<double>("Rage", "BeastAttackRangeMultiplier", 1.25, "Beast normal-rage attack range multiplier (BEA-025).").Value, config.Bind<double>("Rage", "BeastAttackDamageMultiplier", 1.25, "Beast super-rage attack damage multiplier (BEA-026).").Value, config.Bind<double>("Rage", "BeastAttackSpeedBonus", 0.18, "Beast super-rage attack speed bonus (BEA-026).").Value, config.Bind<int>("Rage", "WitchMultiHitSilkPerHit", 1, "Silk per multi-hit attack segment during Witch normal rage (WIT-027).").Value, config.Bind<double>("Rage", "WitchSuperRageMultiHitDamageMultiplier", 2.0, "Witch super-rage multi-hit attack damage multiplier (WIT-028).").Value);
		}

		private static SafetyOptions BindSafety(ConfigFile config)
		{
			return new SafetyOptions(config.Bind<double>("Safety", "MaxCriticalChance", 1.0, "Global critical chance clamp.").Value, config.Bind<double>("Safety", "MaxDamageMultiplier", 50.0, "Global damage multiplier clamp.").Value, config.Bind<int>("Safety", "MaxAdditionalDamageDepth", 1, "Max additional-damage recursion depth.").Value, config.Bind<double>("Safety", "MaxInvulnerabilityLeaseSeconds", 10.0, "Max invulnerability lease duration.").Value);
		}

		public static ToolBalanceOptions BindTools(ConfigFile config)
		{
			return new ToolBalanceOptions(config.Bind<bool>("Tools", "Enabled", true, "Enable virtual tool systems (startup condition).").Value, config.Bind<int>("Tools", "MagazineCapacity", 80, "Architect magazine capacity (ARC-034).").Value, config.Bind<int>("Tools", "ToolReplenishTarget", 1, "Virtual tool replenish target count.").Value, new ToolUpgradeBalanceOptions(config.Bind<bool>("Tools.Upgrades", "Enabled", true, "Enable tool upgrade system (SYS-TOOL-001).").Value, config.Bind<bool>("Tools.Upgrades", "ResetOnCrestSwitch", true, "Clear tool upgrade levels on crest switch (SYS-TOOL-002).").Value, config.Bind<bool>("Tools.Upgrades", "ResetOnBench", true, "Clear tool upgrade levels on bench rest (SYS-TOOL-002).").Value, config.Bind<bool>("Tools.Upgrades", "ResetOnDeath", true, "Clear tool upgrade levels on death (SYS-TOOL-002).").Value, config.Bind<bool>("Tools.Upgrades", "ResetOnSceneChange", false, "Clear tool upgrade levels on scene change (SYS-TOOL-002).").Value, config.Bind<double>("Tools.Upgrades", "MaxDamageMultiplier", 50.0, "Global tool damage multiplier clamp [待实测] (SYS-TOOL-003).").Value, config.Bind<double>("Tools.Upgrades", "MaxAmmoMultiplier", 10.0, "Global tool ammo multiplier clamp [待实测] (SYS-TOOL-003).").Value, config.Bind<double>("Tools.Upgrades", "MinCostMultiplier", 0.5, "Minimum tool cost multiplier [待实测] (SYS-TOOL-003).").Value, config.Bind<double>("Tools.Upgrades", "MinCooldownMultiplier", 0.2, "Minimum tool cooldown multiplier [待实测] (SYS-TOOL-003).").Value, BindToolColor(config, "Red"), BindToolColor(config, "Blue"), BindToolColor(config, "Yellow"), BindToolColor(config, "Skill")));
		}

		private static ToolColorUpgradeOptions BindToolColor(ConfigFile config, string color)
		{
			return new ToolColorUpgradeOptions(config.Bind<bool>("Tools.Upgrades." + color, "Enabled", true, "Enable upgrades for " + color + " tools (SYS-TOOL-001).").Value, config.Bind<int>("Tools.Upgrades." + color, "MaxLevel", 3, color + " tool max upgrade level [待实测] (SYS-TOOL-002).").Value, config.Bind<double>("Tools.Upgrades." + color, "DamageMultiplierPerLevel", 1.1, color + " tool damage multiplier per level [待实测] (SYS-TOOL-001).").Value, config.Bind<double>("Tools.Upgrades." + color, "AmmoMultiplierPerLevel", 1.15, color + " tool ammo multiplier per level [待实测] (SYS-TOOL-001).").Value, config.Bind<double>("Tools.Upgrades." + color, "CostMultiplierPerLevel", 0.95, color + " tool resource cost multiplier per level [待实测] (SYS-TOOL-001).").Value, config.Bind<double>("Tools.Upgrades." + color, "CooldownMultiplierPerLevel", 0.95, color + " tool cooldown multiplier per level [待实测] (SYS-TOOL-001).").Value);
		}
	}
	public sealed record RageProjectionData(bool Rage, bool SuperRage, double RemainingSeconds, long Revision);
	public interface IRageProjection
	{
		RageProjectionData? Current { get; }

		event Action? Changed;
	}
	public sealed class FeatureRuntime : IDisposable
	{
		private readonly ManualLogSource _log;

		private readonly GameEventHub _events;

		private readonly IGameApi _game;

		private readonly IUiPresenter _presenter;

		private IRageProjection? _rage;

		private string _currentCrestId = "";

		private long _projectionRevision;

		public FeatureRuntime(ManualLogSource log, GameEventHub events, IGameApi game, IUiPresenter presenter, IRageProjection? rage = null)
		{
			_log = log;
			_events = events;
			_game = game;
			_presenter = presenter;
			_rage = rage;
		}

		public void AttachRage(IRageProjection? rage)
		{
			if (_rage != null)
			{
				_rage.Changed -= OnRageChanged;
			}
			_rage = rage;
			if (_rage != null)
			{
				_rage.Changed += OnRageChanged;
			}
			PresentActive();
		}

		public void Start()
		{
			_events.CrestChanged += OnCrestChanged;
			_events.BenchRested += OnBenchRested;
			_events.PlayerDamageAfter += OnPlayerDamaged;
			_events.PlayerDied += OnPlayerDied;
			_events.SceneChanged += OnSceneChanged;
			if (_rage != null)
			{
				_rage.Changed += OnRageChanged;
			}
			_currentCrestId = _game.CurrentCrestId ?? "";
			PresentActive();
		}

		public void RefreshProjection()
		{
			PresentActive();
		}

		private void OnCrestChanged(CrestChangedEvent e)
		{
			_currentCrestId = e.Current;
			PresentActive();
		}

		private void OnBenchRested()
		{
			PresentActive();
		}

		private void OnPlayerDamaged(PlayerDamageEvent e)
		{
			PresentActive();
		}

		private void OnPlayerDied()
		{
			PresentActive();
		}

		private void OnSceneChanged(string scene)
		{
			PresentActive();
		}

		private void OnRageChanged()
		{
			PresentActive();
		}

		private void PresentActive()
		{
			RageProjectionData rageProjectionData = _rage?.Current;
			_presenter.Present(new UiProjection(_currentCrestId, 0, 0.0, 0.0, rageProjectionData?.Rage ?? false, rageProjectionData?.SuperRage ?? false, SpecialMode: false, 0, 0, rageProjectionData?.RemainingSeconds ?? 0.0, ++_projectionRevision));
		}

		public void Dispose()
		{
			_events.CrestChanged -= OnCrestChanged;
			_events.BenchRested -= OnBenchRested;
			_events.PlayerDamageAfter -= OnPlayerDamaged;
			_events.PlayerDied -= OnPlayerDied;
			_events.SceneChanged -= OnSceneChanged;
			if (_rage != null)
			{
				_rage.Changed -= OnRageChanged;
			}
		}
	}
	public interface IRuneStateService
	{
		bool RunesActive { get; }

		bool IsActive(string runeKey);
	}
	public sealed class FoundationServices : IDisposable
	{
		public static FoundationServices? Current { get; private set; }

		public ManualLogSource Log { get; }

		public ConfigFile Config { get; }

		public Harmony Harmony { get; }

		public ServiceContainer Container { get; }

		public GameEventHub Events { get; }

		public UnityClock Clock { get; }

		public InvulnerabilityLeaseService Leases { get; }

		public GameBindingConfig Bindings { get; }

		public DynamicPatchResolver Resolver { get; }

		public IGameApi Game { get; }

		public LogUiPresenter Presenter { get; }

		public NeedleforgeAdapter Needleforge { get; }

		public BalanceOptions Balance { get; set; }

		public StatusIconLedger StatusLedger { get; }

		public StatusIconOptions StatusOptions { get; }

		public StatusIconTextureService StatusTextures { get; }

		public StatusIconProjector StatusProjector { get; }

		public StatusIconFeature StatusIcons { get; }

		public FeatureRuntime Runtime { get; }

		public ReaperStateAccessor ReaperState { get; }

		public BeastStateAccessor BeastState { get; }

		public HunterStateAccessor HunterState { get; }

		public DashStateAccessor DashState { get; }

		public DamagePipeline Pipeline { get; }

		public DamageNegotiationService Negotiation { get; }

		public SilkShieldStateService ShieldState { get; }

		public InputChordRouter ChordRouter { get; }

		public IRuneStateService? Runes { get; set; }

		public FoundationServices(ManualLogSource log, ConfigFile config, Harmony harmony, ServiceContainer container, GameEventHub events, UnityClock clock, InvulnerabilityLeaseService leases, GameBindingConfig bindings, DynamicPatchResolver resolver, IGameApi game, LogUiPresenter presenter, NeedleforgeAdapter needleforge, BalanceOptions balance, StatusIconLedger statusLedger, StatusIconOptions statusOptions, StatusIconTextureService statusTextures, StatusIconProjector statusProjector, StatusIconFeature statusIcons, FeatureRuntime runtime, ReaperStateAccessor reaperState, BeastStateAccessor beastState, HunterStateAccessor hunterState, DashStateAccessor dashState, DamagePipeline pipeline, DamageNegotiationService negotiation, SilkShieldStateService shieldState, InputChordRouter chordRouter)
		{
			Log = log;
			Config = config;
			Harmony = harmony;
			Container = container;
			Events = events;
			Clock = clock;
			Leases = leases;
			Bindings = bindings;
			Resolver = resolver;
			Game = game;
			Presenter = presenter;
			Needleforge = needleforge;
			Balance = balance;
			StatusLedger = statusLedger;
			StatusOptions = statusOptions;
			StatusTextures = statusTextures;
			StatusProjector = statusProjector;
			StatusIcons = statusIcons;
			Runtime = runtime;
			ReaperState = reaperState;
			BeastState = beastState;
			HunterState = hunterState;
			DashState = dashState;
			Pipeline = pipeline;
			Negotiation = negotiation;
			ShieldState = shieldState;
			ChordRouter = chordRouter;
		}

		public static void SetCurrent(FoundationServices? services)
		{
			Current = services;
		}

		public void Dispose()
		{
			if (Current == this)
			{
				Current = null;
			}
		}
	}
	public sealed record WhiteToolSpec(string Name, string TextureFile, string RingColorHex, float? PpuOverride = null);
	public static class WhiteToolCatalog
	{
		public const string IoniaName = "Ionia";

		public static readonly IReadOnlyList<WhiteToolSpec> All = new WhiteToolSpec[6]
		{
			new WhiteToolSpec("Ionia", "Ionia.png", "#FFFFFF", 222.22223f),
			new WhiteToolSpec("Fury of the Fallen", "Fury_of_the_Fallen.png", "#B33A3A"),
			new WhiteToolSpec("Void Heart", "Void_Heart.png", "#333333"),
			new WhiteToolSpec("Hiveblood", "Hiveblood.png", "#E8C14A"),
			new WhiteToolSpec("Kingsoul", "Kingsoul.png", "#FFFFFF"),
			new WhiteToolSpec("Weaversong", "Weaversong.png", "#FFFFFF")
		};

		public static readonly IReadOnlyList<WhiteToolSpec> PassiveTools = All.Where((WhiteToolSpec s) => s.Name != "Ionia").ToArray();

		public static readonly IReadOnlyList<string> HiddenFromHud = new string[5] { "Ionia", "Void Heart", "Hiveblood", "Kingsoul", "Weaversong" };

		public static bool IsWhiteTool(string toolName)
		{
			return All.Any((WhiteToolSpec s) => string.Equals(s.Name, toolName, StringComparison.Ordinal));
		}

		public static string? RingColorHexFor(string toolName)
		{
			return All.FirstOrDefault((WhiteToolSpec s) => string.Equals(s.Name, toolName, StringComparison.Ordinal))?.RingColorHex;
		}

		public static WhiteToolSpec? Find(string toolName)
		{
			return All.FirstOrDefault((WhiteToolSpec s) => string.Equals(s.Name, toolName, StringComparison.Ordinal));
		}
	}
}
namespace CrestsEvolve.Features.StatusIcons
{
	public static class StatusIconBinder
	{
		public static StatusIconOptions Bind(ConfigFile config, ManualLogSource log)
		{
			return new StatusIconOptions
			{
				Enabled = config.Bind<bool>("UI.StatusIcons", "Enabled", true, "Master switch: false disables the whole HUD icon system AND passive gameplay (returns to vanilla).").Value,
				RowAnchor = config.Bind<string>("UI.StatusIcons", "RowAnchor", "auto", "Object path relative to BindOrbHudFrame where the vanilla equipped-tool row lives; 'auto' uses the fallback offset until the probe fills this in.").Value,
				FallbackOffset = config.Bind<string>("UI.StatusIcons", "FallbackOffset", "0,-2.2,0", "Local position (x,y,z) used when RowAnchor is 'auto' or not found.").Value,
				Spacing = config.Bind<float>("UI.StatusIcons", "Spacing", 1.1f, "Horizontal spacing between status icons.").Value,
				SkillSignalEnabled = config.Bind<bool>("UI.StatusIcons", "SkillSignalEnabled", true, "Enable the input probe that publishes skill-press events (candidate actions from SkillActionCandidates).").Value,
				SkillActionCandidates = config.Bind<string>("UI.StatusIcons", "SkillActionCandidates", "cast", "Comma-separated native input action candidates for the skill key (probe).").Value,
				RequireSpecialMode = config.Bind<bool>("UI.StatusIcons", "RequireSpecialMode", false, "When true, the fire-blade window only counts inside the Reaper special mode (mode wiring lands later).").Value,
				LogHierarchyProbe = config.Bind<bool>("UI.StatusIcons", "LogHierarchyProbe", true, "Log the HUD child hierarchy once per HUD creation so the vanilla tool row path can be filled into RowAnchor.").Value
			};
		}

		public static StatusIconEntryOptions BindIcon(ConfigFile config, string section, string key, StatusIconEntryOptions defaults)
		{
			return new StatusIconEntryOptions(config.Bind<bool>(section, "Enabled", defaults.Enabled, "Show the " + key + " icon.").Value, config.Bind<int>(section, "Max", defaults.Max, "Max value shown on the " + key + " icon.").Value, config.Bind<string>(section, "ColorHex", defaults.ColorHex, "Ring color of the " + key + " icon.").Value, config.Bind<string>(section, "Texture", defaults.Texture, "Texture key of the " + key + " icon (placeholder / PNG file / game:tool:&lt;name&gt;).").Value, config.Bind<string>(section, "IconColorHex", defaults.IconColorHex, "Center icon tint of the " + key + " icon.").Value);
		}
	}
	public interface IStatusIconDriver : IDisposable
	{
		void Start(string currentCrestId);
	}
	public sealed class StatusIconFeature : IDisposable
	{
		private readonly ManualLogSource? _log;

		private readonly StatusIconLedger _ledger;

		private readonly StatusIconOptions _options;

		private readonly List<IStatusIconDriver> _drivers = new List<IStatusIconDriver>();

		private readonly List<Action<float>> _tickHandlers = new List<Action<float>>();

		private bool _started;

		private string _currentCrestId = "";

		public StatusIconLedger Ledger => _ledger;

		public StatusIconOptions Options => _options;

		public bool Enabled => _options.Enabled;

		public StatusIconFeature(ManualLogSource? log, StatusIconLedger ledger, StatusIconOptions options)
		{
			_log = log;
			_ledger = ledger;
			_options = options;
		}

		public void RegisterDriver(IStatusIconDriver driver)
		{
			if (driver == null)
			{
				throw new ArgumentNullException("driver");
			}
			if (!_drivers.Contains(driver))
			{
				_drivers.Add(driver);
				if (_started)
				{
					driver.Start(_currentCrestId);
				}
			}
		}

		public void AddTick(Action<float> tick)
		{
			if (tick == null)
			{
				throw new ArgumentNullException("tick");
			}
			_tickHandlers.Add(tick);
		}

		public void RegisterIcon(StatusIconDefinition definition)
		{
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			_ledger.Register(definition);
		}

		public static bool ShouldStart(StatusIconOptions? options)
		{
			return options?.Enabled ?? false;
		}

		public void Start(string currentCrestId)
		{
			_currentCrestId = currentCrestId ?? "";
			if (_started)
			{
				return;
			}
			if (!_options.Enabled)
			{
				ManualLogSource? log = _log;
				if (log != null)
				{
					log.LogInfo((object)"[StatusIcons] master switch disabled; HUD icons and passive gameplay remain off.");
				}
				return;
			}
			_started = true;
			foreach (IStatusIconDriver driver in _drivers)
			{
				driver.Start(_currentCrestId);
			}
			ManualLogSource? log2 = _log;
			if (log2 != null)
			{
				log2.LogInfo((object)$"[StatusIcons] feature started with {_drivers.Count} drivers.");
			}
		}

		public void Tick(float deltaSeconds)
		{
			foreach (Action<float> tickHandler in _tickHandlers)
			{
				tickHandler(deltaSeconds);
			}
		}

		public void Dispose()
		{
			foreach (IStatusIconDriver driver in _drivers)
			{
				driver.Dispose();
			}
			_drivers.Clear();
			_tickHandlers.Clear();
		}
	}
	public sealed record StatusIconEntryOptions(bool Enabled, int Max, string ColorHex, string Texture, string IconColorHex = "#FFFFFF");
	public sealed class StatusIconOptions
	{
		public bool Enabled { get; set; } = true;

		public string RowAnchor { get; set; } = "auto";

		public string FallbackOffset { get; set; } = "0,-2.2,0";

		public float Spacing { get; set; } = 1.1f;

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

		public string SkillActionCandidates { get; set; } = "cast";

		public bool RequireSpecialMode { get; set; }

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

		public IReadOnlyDictionary<string, StatusIconEntryOptions> Icons { get; set; } = StatusIconDefaults.CreateEntryDefaults();

		public StatusIconEntryOptions GetIcon(string key)
		{
			if (!Icons.TryGetValue(key, out StatusIconEntryOptions value))
			{
				return new StatusIconEntryOptions(Enabled: true, 1, "#FFFFFF", "placeholder");
			}
			return value;
		}

		public void RegisterIconOptions(IEnumerable<KeyValuePair<string, StatusIconEntryOptions>> entries)
		{
			Dictionary<string, StatusIconEntryOptions> dictionary = new Dictionary<string, StatusIconEntryOptions>(StringComparer.Ordinal);
			foreach (KeyValuePair<string, StatusIconEntryOptions> icon in Icons)
			{
				dictionary[icon.Key] = icon.Value;
			}
			foreach (KeyValuePair<string, StatusIconEntryOptions> entry in entries)
			{
				dictionary[entry.Key] = entry.Value;
			}
			Icons = dictionary;
		}
	}
	public static class StatusIconDefaults
	{
		public sealed record IconDefault(string Key, string Owner, int Max, string ColorHex, string IconColorHex = "#FFFFFF", string? Texture = null);

		public const string YellowColor = "#E8C14A";

		public const string BlueColor = "#5A9BD6";

		public const string RedColor = "#B33A3A";

		public const string GreenColor = "#7FB069";

		public static readonly IReadOnlyList<IconDefault> All = new IconDefault[19]
		{
			new IconDefault("hunter.conqueror", "hunter", 12, "#E8C14A", "#FFFFFF", "1.png"),
			new IconDefault("architect.charge", "architect-electrocute", 3, "#B33A3A", "#FFFFFF", "2.png"),
			new IconDefault("wanderer.combo", "wanderer", 6, "#E8C14A", "#FFFFFF", "3.png"),
			new IconDefault("beast.enhancement", "beast", 24, "#B33A3A", "#FFFFFF", "4.png"),
			new IconDefault("beast.predator", "beast-predator", 10, "#B33A3A", "#FFFFFF", "16.png"),
			new IconDefault("witch.cycle", "witch", 4, "#7FB069", "#FFFFFF", "5.png"),
			new IconDefault("witch.swift", "witch-swift", 6, "#E8C14A", "#FFFFFF", "10.png"),
			new IconDefault("architect.cycle", "architect", 10, "#5A9BD6", "#FFFFFF", "6.png"),
			new IconDefault("shaman.cycle", "shaman", 10, "#5A9BD6", "#FFFFFF", "7.png"),
			new IconDefault("shaman.phase", "shaman-phase", 8, "#5A9BD6", "#FFFFFF", "17.png"),
			new IconDefault("reaper.strong", "reaper-strong", 24, "#E8C14A", "#FFFFFF", "9.png"),
			new IconDefault("reaper.subblade", "reaper-subblade", 9, "#B33A3A", "#FFFFFF", "11.png"),
			new IconDefault("cursed.aftershock", "cursed-aftershock", 10, "#7FB069", "#FFFFFF", "12.png"),
			new IconDefault("cursed.guardian", "cursed-guardian", 4, "#7FB069", "#FFFFFF", "14.png"),
			new IconDefault("cloakless.glacial", "cloakless-glacial", 25, "#5A9BD6", "#FFFFFF", "13.png"),
			new IconDefault("cloakless.spellbook", "cloakless-spellbook", 1, "#5A9BD6", "#FFFFFF", "15.png"),
			new IconDefault("rage.fury", "rage", 1, "#B33A3A", "#FFFFFF", "Fury_of_the_Fallen.png"),
			new IconDefault("hunter.super-rage", "rage-plus", 10, "#FFFFFF", "#FFFFFF", "placeholder"),
			new IconDefault("wanderer.super-rage", "rage-plus", 10, "#FFFFFF", "#FFFFFF", "placeholder")
		};

		public static Dictionary<string, StatusIconEntryOptions> CreateEntryDefaults()
		{
			Dictionary<string, StatusIconEntryOptions> dictionary = new Dictionary<string, StatusIconEntryOptions>(StringComparer.Ordinal);
			foreach (IconDefault item in All)
			{
				dictionary[item.Key] = new StatusIconEntryOptions(Enabled: true, item.Max, item.ColorHex, item.Texture ?? "placeholder", item.IconColorHex);
			}
			return dictionary;
		}
	}
}
namespace CrestsEvolve.Features.Tools
{
	public static class IoniaDescription
	{
		public sealed record TextEntry(string Sheet, string Key, string Text);

		public const string Sheet = "Mods.local.crestsevolve";

		public const string Text = "艾欧尼亚：白色工具，佩戴后激活全部天赋符文；同时保留骰子白显示等专属逻辑。\n亡者之怒：白色工具，任意槽位佩戴即作为全部亡怒效果（普通亡怒 + 超级亡怒/亡怒plus）的门控；白槽佩戴时血量上限直接投影为 1 格。\n征服者（猎手）：每次普攻+1层，5秒无普攻-1层，平A刷新CD；满12层蓝黄工具+1级。\n致命节奏（漫游者）：非法术伤害叠层，每层攻速+6%，满6层距离+25%，每6秒无伤害-1层。\n电刑（建筑师）：15秒+1层，伤害+1层，满3层下一击燃爆。\n强攻（收割者）：强化前4秒丝球掉率15/50/35，之后恢复；强化期丝球自动收集，蓄力斩1.6。\n丛刃（收割者）：每10秒获得3/3充能，充能期攻速+30%，3次普攻消耗完。\n火刀（收割者）：挥刀窗口叠层；3层拼刀/冲刺/蓄力燃爆，普攻耗1层。\n掠食者（野兽）：10秒计时，满层蓄力攻击伤害×1.2+无敌+回血转红血。\n黑暗收割（野兽）：击杀+4秒强化（上限10秒），受伤不打断，下劈无敌。\n不灭之握（女巫）：普攻叠层，每3秒-1层；满4层下一次普攻伤害×1.3并+1绿血；层数>0下劈×1.5。\n迅捷步伐（女巫）：冲刺叠层，偶数层冲刺无敌；满10层攻击+1绿血和3秒跳蚤蜜酿。\n先攻（建筑师）：10秒计时，满层攻击后获得与伤害等额的碎片；补弹时修复其他纹章工具。\n奥术彗星（萨满）：10秒计时，满层技能命中召唤蓝色灵火；法术击杀获得8秒跳蚤蜜酿（相位猛冲）。\n国王之魂：任意槽位佩戴后蓝色工具等级+1；白槽佩戴额外技能伤害×1.5。虚空之心：任意槽位佩戴后蓝色工具等级+1；白槽佩戴额外针刺伤害×1.5（同色可叠加）。\n编织者之歌：任意槽位佩戴后黄色工具等级+1；白槽佩戴额外工具伤害×1.5。蜂巢之血：任意槽位佩戴后黄色工具等级+1；白槽佩戴额外攻击间隔-42%（同色可叠加）。";

		public static readonly IReadOnlyList<TextEntry> Entries = new TextEntry[12]
		{
			new TextEntry("Mods.local.crestsevolve", "Ionia", "艾欧尼亚"),
			new TextEntry("Mods.local.crestsevolve", "IoniaDesc", "艾欧尼亚：白色工具，佩戴后激活全部天赋符文；同时保留骰子白显示等专属逻辑。\n亡者之怒：白色工具，任意槽位佩戴即作为全部亡怒效果（普通亡怒 + 超级亡怒/亡怒plus）的门控；白槽佩戴时血量上限直接投影为 1 格。\n征服者（猎手）：每次普攻+1层，5秒无普攻-1层，平A刷新CD；满12层蓝黄工具+1级。\n致命节奏（漫游者）：非法术伤害叠层，每层攻速+6%，满6层距离+25%，每6秒无伤害-1层。\n电刑（建筑师）：15秒+1层，伤害+1层，满3层下一击燃爆。\n强攻（收割者）：强化前4秒丝球掉率15/50/35，之后恢复；强化期丝球自动收集，蓄力斩1.6。\n丛刃（收割者）：每10秒获得3/3充能，充能期攻速+30%，3次普攻消耗完。\n火刀（收割者）：挥刀窗口叠层；3层拼刀/冲刺/蓄力燃爆，普攻耗1层。\n掠食者（野兽）：10秒计时，满层蓄力攻击伤害×1.2+无敌+回血转红血。\n黑暗收割（野兽）：击杀+4秒强化（上限10秒），受伤不打断，下劈无敌。\n不灭之握（女巫）：普攻叠层，每3秒-1层；满4层下一次普攻伤害×1.3并+1绿血；层数>0下劈×1.5。\n迅捷步伐（女巫）：冲刺叠层，偶数层冲刺无敌；满10层攻击+1绿血和3秒跳蚤蜜酿。\n先攻（建筑师）：10秒计时，满层攻击后获得与伤害等额的碎片；补弹时修复其他纹章工具。\n奥术彗星（萨满）：10秒计时，满层技能命中召唤蓝色灵火；法术击杀获得8秒跳蚤蜜酿（相位猛冲）。\n国王之魂：任意槽位佩戴后蓝色工具等级+1；白槽佩戴额外技能伤害×1.5。虚空之心：任意槽位佩戴后蓝色工具等级+1；白槽佩戴额外针刺伤害×1.5（同色可叠加）。\n编织者之歌：任意槽位佩戴后黄色工具等级+1；白槽佩戴额外工具伤害×1.5。蜂巢之血：任意槽位佩戴后黄色工具等级+1；白槽佩戴额外攻击间隔-42%（同色可叠加）。"),
			new TextEntry("Mods.local.crestsevolve", "Fury of the Fallen", "亡者之怒"),
			new TextEntry("Mods.local.crestsevolve", "Fury of the FallenDesc", "艾欧尼亚：白色工具，佩戴后激活全部天赋符文；同时保留骰子白显示等专属逻辑。\n亡者之怒：白色工具，任意槽位佩戴即作为全部亡怒效果（普通亡怒 + 超级亡怒/亡怒plus）的门控；白槽佩戴时血量上限直接投影为 1 格。\n征服者（猎手）：每次普攻+1层，5秒无普攻-1层，平A刷新CD；满12层蓝黄工具+1级。\n致命节奏（漫游者）：非法术伤害叠层，每层攻速+6%，满6层距离+25%，每6秒无伤害-1层。\n电刑（建筑师）：15秒+1层，伤害+1层，满3层下一击燃爆。\n强攻（收割者）：强化前4秒丝球掉率15/50/35，之后恢复；强化期丝球自动收集，蓄力斩1.6。\n丛刃（收割者）：每10秒获得3/3充能，充能期攻速+30%，3次普攻消耗完。\n火刀（收割者）：挥刀窗口叠层；3层拼刀/冲刺/蓄力燃爆，普攻耗1层。\n掠食者（野兽）：10秒计时，满层蓄力攻击伤害×1.2+无敌+回血转红血。\n黑暗收割（野兽）：击杀+4秒强化（上限10秒），受伤不打断，下劈无敌。\n不灭之握（女巫）：普攻叠层，每3秒-1层；满4层下一次普攻伤害×1.3并+1绿血；层数>0下劈×1.5。\n迅捷步伐（女巫）：冲刺叠层，偶数层冲刺无敌；满10层攻击+1绿血和3秒跳蚤蜜酿。\n先攻（建筑师）：10秒计时，满层攻击后获得与伤害等额的碎片；补弹时修复其他纹章工具。\n奥术彗星（萨满）：10秒计时，满层技能命中召唤蓝色灵火；法术击杀获得8秒跳蚤蜜酿（相位猛冲）。\n国王之魂：任意槽位佩戴后蓝色工具等级+1；白槽佩戴额外技能伤害×1.5。虚空之心：任意槽位佩戴后蓝色工具等级+1；白槽佩戴额外针刺伤害×1.5（同色可叠加）。\n编织者之歌：任意槽位佩戴后黄色工具等级+1；白槽佩戴额外工具伤害×1.5。蜂巢之血：任意槽位佩戴后黄色工具等级+1；白槽佩戴额外攻击间隔-42%（同色可叠加）。"),
			new TextEntry("Mods.local.crestsevolve", "Void Heart", "虚空之心"),
			new TextEntry("Mods.local.crestsevolve", "Void HeartDesc", "任意槽位佩戴后蓝色工具等级+1；白槽佩戴额外针刺伤害×1.5。"),
			new TextEntry("Mods.local.crestsevolve", "Hiveblood", "蜂巢之血"),
			new TextEntry("Mods.local.crestsevolve", "HivebloodDesc", "任意槽位佩戴后黄色工具等级+1；白槽佩戴额外攻击间隔-42%。"),
			new TextEntry("Mods.local.crestsevolve", "Kingsoul", "国王之魂"),
			new TextEntry("Mods.local.crestsevolve", "KingsoulDesc", "任意槽位佩戴后蓝色工具等级+1；白槽佩戴额外技能伤害×1.5。"),
			new TextEntry("Mods.local.crestsevolve", "Weaversong", "编织者之歌"),
			new TextEntry("Mods.local.crestsevolve", "WeaversongDesc", "任意槽位佩戴后黄色工具等级+1；白槽佩戴额外工具伤害×1.5。")
		};
	}
	public static class ToolDescriptionRegistry
	{
		private static readonly Dictionary<string, string> Suffixes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		public static void Register(string toolName, string? suffixText)
		{
			if (!string.IsNullOrWhiteSpace(toolName))
			{
				if (string.IsNullOrWhiteSpace(suffixText))
				{
					Suffixes.Remove(toolName);
				}
				else
				{
					Suffixes[toolName] = suffixText;
				}
			}
		}

		public static bool TryGetSuffix(string toolName, out string suffix)
		{
			if (!string.IsNullOrWhiteSpace(toolName))
			{
				return Suffixes.TryGetValue(toolName, out suffix);
			}
			suffix = string.Empty;
			return false;
		}

		public static void Clear()
		{
			Suffixes.Clear();
		}
	}
}
namespace CrestsEvolve.Core.UI
{
	public sealed record StatusIconDefinition(string Key, string Owner, int MaxValue);
	public sealed record StatusIconValue(string Key, int Current, int Max, bool Visible = true, string? ColorOverride = null, string? Text = null, bool Dimmed = false);
	public sealed record StatusIconSnapshot(long Revision, IReadOnlyList<StatusIconValue> Icons);
	public sealed class StatusIconLedger
	{
		private sealed class Entry
		{
			public string Owner { get; }

			public int Max { get; set; }

			public int Current { get; set; }

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

			public string? ColorOverride { get; set; }

			public string? Text { get; set; }

			public bool Dimmed { get; set; }

			public Entry(string owner, int max, int current)
			{
				Owner = owner;
				Max = max;
				Current = current;
			}
		}

		private readonly Dictionary<string, Entry> _icons = new Dictionary<string, Entry>(StringComparer.Ordinal);

		private readonly List<string> _order = new List<string>();

		public long Revision { get; private set; }

		public event Action<StatusIconSnapshot>? Changed;

		public bool IsRegistered(string key)
		{
			return _icons.ContainsKey(key);
		}

		public void Register(StatusIconDefinition definition)
		{
			if ((object)definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			if (string.IsNullOrWhiteSpace(definition.Key))
			{
				throw new ArgumentException("Icon key is required.", "definition");
			}
			if (string.IsNullOrWhiteSpace(definition.Owner))
			{
				throw new ArgumentException("Icon owner is required.", "definition");
			}
			if (definition.MaxValue <= 0)
			{
				throw new ArgumentOutOfRangeException("definition", "Icon max must be positive.");
			}
			if (_icons.TryGetValue(definition.Key, out Entry value))
			{
				if (value.Owner != definition.Owner)
				{
					throw new InvalidOperationException("Icon '" + definition.Key + "' is owned by '" + value.Owner + "', not '" + definition.Owner + "'.");
				}
				if (value.Max != definition.MaxValue)
				{
					throw new InvalidOperationException($"Icon '{definition.Key}' is already registered with max {value.Max}.");
				}
			}
			else
			{
				_icons.Add(definition.Key, new Entry(definition.Owner, definition.MaxValue, 0));
				_order.Add(definition.Key);
				Revision++;
				Emit();
			}
		}

		public void RegisterRange(IEnumerable<StatusIconDefinition> definitions)
		{
			if (definitions == null)
			{
				throw new ArgumentNullException("definitions");
			}
			foreach (StatusIconDefinition definition in definitions)
			{
				Register(definition);
			}
		}

		public void Set(string key, string owner, int current)
		{
			Entry entry = Require(key, owner);
			int num = Clamp(entry, current);
			if (entry.Current != num)
			{
				entry.Current = num;
				Revision++;
				Emit();
			}
		}

		public void SetMax(string key, string owner, int max)
		{
			if (max <= 0)
			{
				throw new ArgumentOutOfRangeException("max", "Icon max must be positive.");
			}
			Entry entry = Require(key, owner);
			if (entry.Max != max)
			{
				entry.Max = max;
				entry.Current = Clamp(entry, entry.Current);
				Revision++;
				Emit();
			}
		}

		public int Add(string key, string owner, int amount)
		{
			if (amount <= 0)
			{
				throw new ArgumentOutOfRangeException("amount");
			}
			Entry entry = Require(key, owner);
			int num = Clamp(entry, entry.Current + amount);
			if (entry.Current == num)
			{
				return entry.Current;
			}
			entry.Current = num;
			Revision++;
			Emit();
			return entry.Current;
		}

		public int Consume(string key, string owner, int amount = 1)
		{
			if (amount <= 0)
			{
				throw new ArgumentOutOfRangeException("amount");
			}
			Entry entry = Require(key, owner);
			int num = Math.Max(0, entry.Current - amount);
			if (entry.Current == num)
			{
				return entry.Current;
			}
			entry.Current = num;
			Revision++;
			Emit();
			return entry.Current;
		}

		public void Reset(string key, string owner)
		{
			Entry entry = Require(key, owner);
			if (entry.Current != 0)
			{
				entry.Current = 0;
				Revision++;
				Emit();
			}
		}

		public void SetVisible(string key, string owner, bool visible)
		{
			Entry entry = Require(key, owner);
			if (entry.Visible != visible)
			{
				entry.Visible = visible;
				Revision++;
				Emit();
			}
		}

		public void SetColorOverride(string key, string owner, string? colorHex)
		{
			Entry entry = Require(key, owner);
			if (!string.Equals(entry.ColorOverride, colorHex, StringComparison.OrdinalIgnoreCase))
			{
				entry.ColorOverride = colorHex;
				Revision++;
				Emit();
			}
		}

		public void SetText(string key, string owner, string? text)
		{
			Entry entry = Require(key, owner);
			if (!string.Equals(entry.Text, text, StringComparison.Ordinal))
			{
				entry.Text = text;
				Revision++;
				Emit();
			}
		}

		public void SetDimmed(string key, string owner, bool dimmed)
		{
			Entry entry = Require(key, owner);
			if (entry.Dimmed != dimmed)
			{
				entry.Dimmed = dimmed;
				Revision++;
				Emit();
			}
		}

		public void Touch(string key, string owner)
		{
			Require(key, owner);
			Revision++;
			Emit();
		}

		public void ResetAll()
		{
			bool flag = false;
			foreach (Entry value in _icons.Values)
			{
				if (value.Current != 0)
				{
					value.Current = 0;
					flag = true;
				}
			}
			if (flag)
			{
				Revision++;
				Emit();
			}
		}

		public StatusIconSnapshot Snapshot()
		{
			List<StatusIconValue> list = new List<StatusIconValue>(_icons.Count);
			foreach (string item in _order)
			{
				Entry entry = _icons[item];
				list.Add(new StatusIconValue(item, entry.Current, entry.Max, entry.Visible, entry.ColorOverride, entry.Text, entry.Dimmed));
			}
			return new StatusIconSnapshot(Revision, list);
		}

		private Entry Require(string key, string owner)
		{
			if (!_icons.TryGetValue(key, out Entry value))
			{
				throw new InvalidOperationException("Icon '" + key + "' is not registered.");
			}
			if (value.Owner != owner)
			{
				throw new InvalidOperationException("Icon '" + key + "' is owned by '" + value.Owner + "', not '" + owner + "'.");
			}
			return value;
		}

		private void Emit()
		{
			this.Changed?.Invoke(Snapshot());
		}

		private static int Clamp(Entry entry, int value)
		{
			return Math.Max(0, Math.Min(entry.Max, value));
		}
	}
	public static class StatusIconProjectionRules
	{
		public static bool ZeroValueVisible(string? key)
		{
			if (key != null)
			{
				if (!(key == "rage.fury"))
				{
					return key.StartsWith("imc.second.", StringComparison.Ordinal);
				}
				return true;
			}
			return false;
		}
	}
	public enum StatusIconCountDirection
	{
		CountUp,
		CountDown
	}
	public sealed class StatusIconTimer
	{
		private readonly StatusIconLedger _ledger;

		private readonly string _key;

		private readonly string _owner;

		private readonly int _max;

		private readonly StatusIconCountDirection _direction;

		private readonly bool _holdAtEnd;

		private readonly IClock _clock;

		private double _accumulator;

		private int _current;

		private bool _reached;

		public int Current => _current;

		public int Max => _max;

		public bool Reached => _reached;

		public StatusIconTimer(StatusIconLedger ledger, StatusIconDefinition definition, StatusIconCountDirection direction, bool holdAtEnd, IClock clock, int initialCurrent = 0)
		{
			_ledger = ledger ?? throw new ArgumentNullException("ledger");
			_key = definition.Key;
			_owner = definition.Owner;
			_max = definition.MaxValue;
			_direction = direction;
			_holdAtEnd = holdAtEnd;
			_clock = clock ?? throw new ArgumentNullException("clock");
			_current = Math.Max(0, Math.Min(_max, initialCurrent));
			_ledger.Set(_key, _owner, _current);
		}

		public void Tick(double deltaSeconds)
		{
			if (deltaSeconds < 0.0)
			{
				throw new ArgumentOutOfRangeException("deltaSeconds");
			}
			if (_reached && _holdAtEnd)
			{
				return;
			}
			int current = _current;
			_accumulator += deltaSeconds;
			while (_accumulator >= 1.0 && !_reached)
			{
				_accumulator -= 1.0;
				_current = ((_direction == StatusIconCountDirection.CountUp) ? Math.Min(_max, _current + 1) : Math.Max(0, _current - 1));
				if (_current == 0 && _direction == StatusIconCountDirection.CountDown)
				{
					_reached = true;
					if (!_holdAtEnd)
					{
						ResetCore();
					}
				}
				else if (_current == _max && _direction == StatusIconCountDirection.CountUp)
				{
					_reached = true;
					if (!_holdAtEnd)
					{
						ResetCore();
					}
				}
			}
			if (_current != current)
			{
				_ledger.Set(_key, _owner, _current);
			}
		}

		public void Consume()
		{
			ResetCore();
			_ledger.Set(_key, _owner, _current);
		}

		public void ResetToZero()
		{
			_accumulator = 0.0;
			_reached = false;
			_current = 0;
			_ledger.Set(_key, _owner, _current);
		}

		private void ResetCore()
		{
			_accumulator = 0.0;
			_reached = false;
			_current = ((_direction != StatusIconCountDirection.CountUp) ? _max : 0);
		}
	}
	public sealed record ToolRowLayout(float StartX, float RowY, float Spacing);
	public static class ToolRowLayoutCalculator
	{
		public const float MinSpacing = 0.5f;

		public const float MaxSpacing = 3f;

		public static ToolRowLayout Calculate(IReadOnlyList<float> iconPositionsX, float? referenceY, float fallbackSpacing, float fallbackStartX)
		{
			if (fallbackSpacing <= 0f)
			{
				throw new ArgumentOutOfRangeException("fallbackSpacing");
			}
			float num = fallbackSpacing;
			float startX = fallbackStartX;
			if (iconPositionsX != null && iconPositionsX.Count > 0)
			{
				float[] array = (from x in iconPositionsX.Distinct()
					orderby x
					select x).ToArray();
				if (array.Length >= 2)
				{
					float num2 = (array[^1] - array[0]) / (float)(array.Length - 1);
					if (num2 > 0.01f)
					{
						num = Math.Clamp(num2, 0.5f, 3f);
					}
				}
				startX = array[^1] + num;
			}
			return new ToolRowLayout(startX, referenceY.GetValueOrDefault(), num);
		}
	}
}
namespace CrestsEvolve.Core.Tools
{
	public enum ToolColorKind
	{
		Red,
		Blue,
		Yellow,
		Skill
	}
	public sealed record ToolColorUpgradeOptions(bool Enabled, int MaxLevel, double DamageMultiplierPerLevel, double AmmoMultiplierPerLevel, double CostMultiplierPerLevel, double CooldownMultiplierPerLevel)
	{
		public static ToolColorUpgradeOptions Defaults { get; } = new ToolColorUpgradeOptions(Enabled: true, 3, 1.1, 1.15, 0.95, 0.95);

		public IReadOnlyList<string> Validate(string color)
		{
			List<string> list = new List<string>();
			int maxLevel = MaxLevel;
			if ((maxLevel < 0 || maxLevel > 99) ? true : false)
			{
				list.Add("Tools.Upgrades." + color + ".MaxLevel must be in [0,99]");
			}
			if (DamageMultiplierPerLevel < 1.0)
			{
				list.Add("Tools.Upgrades." + color + ".DamageMultiplierPerLevel must be >= 1");
			}
			if (AmmoMultiplierPerLevel < 1.0)
			{
				list.Add("Tools.Upgrades." + color + ".AmmoMultiplierPerLevel must be >= 1");
			}
			double costMultiplierPerLevel = CostMultiplierPerLevel;
			if ((costMultiplierPerLevel <= 0.0 || costMultiplierPerLevel > 1.0) ? true : false)
			{
				list.Add("Tools.Upgrades." + color + ".CostMultiplierPerLevel must be in (0,1]");
			}
			costMultiplierPerLevel = CooldownMultiplierPerLevel;
			if ((costMultiplierPerLevel <= 0.0 || costMultiplierPerLevel > 1.0) ? true : false)
			{
				list.Add("Tools.Upgrades." + color + ".CooldownMultiplierPerLevel must be in (0,1]");
			}
			return list;
		}

		[CompilerGenerated]
		private ToolColorUpgradeOptions(ToolColorUpgradeOptions original)
		{
			Enabled = original.Enabled;
			MaxLevel = original.MaxLevel;
			DamageMultiplierPerLevel = original.DamageMultiplierPerLevel;
			AmmoMultiplierPerLevel = original.AmmoMultiplierPerLevel;
			CostMultiplierPerLevel = original.CostMultiplierPerLevel;
			CooldownMultiplierPerLevel = original.CooldownMultiplierPerLevel;
		}
	}
	public sealed record ToolUpgradeBalanceOptions(bool Enabled, bool ResetOnCrestSwitch, bool ResetOnBench, bool ResetOnDeath, bool ResetOnSceneChange, double MaxDamageMultiplier, double MaxAmmoMultiplier, double MinCostMultiplier, double MinCooldownMultiplier, ToolColorUpgradeOptions Red, ToolColorUpgradeOptions Blue, ToolColorUpgradeOptions Yellow, ToolColorUpgradeOptions Skill)
	{
		public static ToolUpgradeBalanceOptions Defaults { get; } = new ToolUpgradeBalanceOptions(Enabled: true, ResetOnCrestSwitch: true, ResetOnBench: true, ResetOnDeath: true, ResetOnSceneChange: false, 50.0, 10.0, 0.5, 0.2, ToolColorUpgradeOptions.Defaults, ToolColorUpgradeOptions.Defaults, ToolColorUpgradeOptions.Defaults, ToolColorUpgradeOptions.Defaults);

		public IReadOnlyList<string> Validate()
		{
			List<string> list = new List<string>();
			if (MaxDamageMultiplier < 1.0)
			{
				list.Add("Tools.Upgrades.MaxDamageMultiplier must be >= 1");
			}
			if (MaxAmmoMultiplier < 1.0)
			{
				list.Add("Tools.Upgrades.MaxAmmoMultiplier must be >= 1");
			}
			double minCostMultiplier = MinCostMultiplier;
			if ((minCostMultiplier < 0.0 || minCostMultiplier > 1.0) ? true : false)
			{
				list.Add("Tools.Upgrades.MinCostMultiplier must be in [0,1]");
			}
			minCostMultiplier = MinCooldownMultiplier;
			if ((minCostMultiplier < 0.0 || minCostMultiplier > 1.0) ? true : false)
			{
				list.Add("Tools.Upgrades.MinCooldownMultiplier must be in [0,1]");
			}
			list.AddRange(Red.Validate("Red"));
			list.AddRange(Blue.Validate("Blue"));
			list.AddRange(Yellow.Validate("Yellow"));
			list.AddRange(Skill.Validate("Skill"));
			return list;
		}

		public ToolColorUpgradeOptions For(ToolColorKind color)
		{
			return color switch
			{
				ToolColorKind.Red => Red, 
				ToolColorKind.Blue => Blue, 
				ToolColorKind.Yellow => Yellow, 
				_ => Skill, 
			};
		}

		[CompilerGenerated]
		private ToolUpgradeBalanceOptions(ToolUpgradeBalanceOptions original)
		{
			Enabled = original.Enabled;
			ResetOnCrestSwitch = original.ResetOnCrestSwitch;
			ResetOnBench = original.ResetOnBench;
			ResetOnDeath = original.ResetOnDeath;
			ResetOnSceneChange = original.ResetOnSceneChange;
			MaxDamageMultiplier = original.MaxDamageMultiplier;
			MaxAmmoMultiplier = original.MaxAmmoMultiplier;
			MinCostMultiplier = original.MinCostMultiplier;
			MinCooldownMultiplier = original.MinCooldownMultiplier;
			Red = original.Red;
			Blue = original.Blue;
			Yellow = original.Yellow;
			Skill = original.Skill;
		}
	}
}
namespace CrestsEvolve.Core.Time
{
	public interface IClock
	{
		double Now { get; }
	}
	public sealed class UnityClock : IClock
	{
		public double Now => Time.timeAsDouble;
	}
}
namespace CrestsEvolve.Core.State
{
	public static class AttackCycleSpeed
	{
		public const double DefaultPerLayer = 0.06;

		public static double TimeFactor(int layers, double perLayer = 0.06)
		{
			if (layers <= 0)
			{
				return 1.0;
			}
			if (perLayer <= 0.0)
			{
				return 1.0;
			}
			return 1.0 / (1.0 + perLayer * (double)layers);
		}
	}
	public enum RageMode
	{
		None,
		Rage,
		SuperRage
	}
	public sealed class CrestRuntimeState
	{
		private readonly Dictionary<string, object> _values = new Dictionary<string, object>(StringComparer.Ordinal);

		public string CrestId { get; private set; } = "none";

		public RageMode Rage { get; set; }

		public bool SpecialMode { get; set; }

		public long Revision { get; private set; }

		public void Activate(string crestId)
		{
			ResetTransient();
			CrestId = crestId;
			Revision++;
		}

		public T Get<T>(string key, T fallback = default(T))
		{
			if (_values.TryGetValue(key, out object value) && value is T)
			{
				return (T)value;
			}
			return fallback;
		}

		public void Set<T>(string key, T value)
		{
			_values[key] = value;
			Revision++;
		}

		public void Remove(string key)
		{
			if (_values.Remove(key))
			{
				Revision++;
			}
		}

		public void ResetTransient()
		{
			_values.Clear();
			Rage = RageMode.None;
			SpecialMode = false;
			Revision++;
		}
	}
	public sealed class DecayingStackCounter
	{
		private readonly IClock _clock;

		private readonly int _max;

		private readonly double _firstDecayDelay;

		private readonly double _decayInterval;

		private int _count;

		private int _floor;

		private double? _nextDecayAt;

		public int Count => _count;

		public int Floor => _floor;

		public event Action<int>? Changed;

		public event Action<int>? ThresholdReached;

		public DecayingStackCounter(IClock clock, int max, double firstDecayDelay, double decayInterval)
		{
			_clock = clock ?? throw new ArgumentNullException("clock");
			if (max <= 0)
			{
				throw new ArgumentOutOfRangeException("max");
			}
			if (firstDecayDelay <= 0.0)
			{
				throw new ArgumentOutOfRangeException("firstDecayDelay");
			}
			if (decayInterval <= 0.0)
			{
				throw new ArgumentOutOfRangeException("decayInterval");
			}
			_max = max;
			_firstDecayDelay = firstDecayDelay;
			_decayInterval = decayInterval;
		}

		public int Add(int amount = 1, params int[] thresholds)
		{
			if (amount <= 0)
			{
				throw new ArgumentOutOfRangeException("amount");
			}
			int count = _count;
			_count = Math.Min(_max, _count + amount);
			_nextDecayAt = _clock.Now + _firstDecayDelay;
			RaiseThresholds(count, thresholds);
			this.Changed?.Invoke(_count);
			return _count;
		}

		public void Tick()
		{
			bool flag = false;
			while (_nextDecayAt.HasValue && _clock.Now >= _nextDecayAt.Value && _count > _floor)
			{
				_count--;
				_nextDecayAt = ((_count > _floor) ? new double?(_nextDecayAt.Value + _decayInterval) : ((double?)null));
				flag = true;
			}
			if (flag)
			{
				this.Changed?.Invoke(_count);
			}
		}

		public void SetFloor(int floor)
		{
			if (floor < 0)
			{
				throw new ArgumentOutOfRangeException("floor");
			}
			int num = Math.Min(_max, floor);
			if (num != _floor || _count < num)
			{
				int floor2 = _floor;
				_floor = num;
				if (num < floor2 && _count == floor2)
				{
					_count = num;
				}
				if (_count < _floor)
				{
					_count = _floor;
					_nextDecayAt = ((_count > 0) ? new double?(_clock.Now + _firstDecayDelay) : ((double?)null));
				}
				else if (_count == _floor)
				{
					_nextDecayAt = null;
				}
				this.Changed?.Invoke(_count);
			}
		}

		public void Clear()
		{
			if (_count == _floor)
			{
				_nextDecayAt = null;
				return;
			}
			_count = _floor;
			_nextDecayAt = null;
			this.Changed?.Invoke(_count);
		}

		public int Consume(int amount)
		{
			if (amount <= 0)
			{
				throw new ArgumentOutOfRangeException("amount");
			}
			if (_count == _floor)
			{
				return _count;
			}
			_count = Math.Max(_floor, _count - amount);
			if (_count == _floor)
			{
				_nextDecayAt = null;
			}
			this.Changed?.Invoke(_count);
			return _count;
		}

		private void RaiseThresholds(int previous, int[] thresholds)
		{
			foreach (int num in thresholds)
			{
				if (previous < num && _count >= num)
				{
					this.ThresholdReached?.Invoke(num);
				}
			}
		}
	}
	public sealed class FracturedMaskState
	{
		public const int Initial = 3;

		private readonly int _max;

		public int Charges { get; private set; }

		public int Max => _max;

		public FracturedMaskState(int max = 6)
		{
			if (max <= 0)
			{
				throw new ArgumentOutOfRangeException("max");
			}
			_max = max;
		}

		public void SetInitial(int level)
		{
			Charges = Math.Min(3, _max);
		}

		public bool OnBreak()
		{
			if (Charges <= 1)
			{
				Charges = 0;
				return false;
			}
			Charges--;
			return true;
		}

		public void OnEnemyKilledInWhiteSlot()
		{
			Charges = Math.Min(_max, Charges + 1);
		}

		public void Reset()
		{
			Charges = 0;
		}
	}
	public sealed class ReserveBindState
	{
		public const int Max = 6;

		public const int Initial = 3;

		public int Charges { get; private set; }

		public void SetInitial(int level)
		{
			Charges = 3;
		}

		public bool OnFreeBindUsed()
		{
			if (Charges <= 0)
			{
				return false;
			}
			Charges--;
			return true;
		}

		public void OnEnemyKilledInWhiteSlot()
		{
			Charges = Math.Min(6, Charges + 1);
		}

		public void Reset()
		{
			Charges = 0;
		}
	}
	public enum ResetReason
	{
		CrestSwitch,
		BenchRested,
		Damaged,
		Died,
		Respawned,
		SceneChanged,
		SaveLoaded,
		Disabled,
		ToolGate
	}
	public sealed class TimedStackCounter
	{
		private readonly IClock _clock;

		private readonly int _maxStacks;

		private readonly double _durationSeconds;

		private double _expiresAt;

		public int Count { get; private set; }

		public bool IsActive
		{
			get
			{
				if (Count > 0)
				{
					return RemainingSeconds > 0.0;
				}
				return false;
			}
		}

		public double RemainingSeconds
		{
			get
			{
				if (Count != 0)
				{
					return Math.Max(0.0, _expiresAt - _clock.Now);
				}
				return 0.0;
			}
		}

		public event EventHandler<StackChangedEventArgs>? Changed;

		public event EventHandler<ThresholdReachedEventArgs>? ThresholdReached;

		public event EventHandler? Expired;

		public TimedStackCounter(int maxStacks, double durationSeconds, IClock clock)
		{
			if (maxStacks <= 0)
			{
				throw new ArgumentOutOfRangeException("maxStacks");
			}
			if (durationSeconds <= 0.0)
			{
				throw new ArgumentOutOfRangeException("durationSeconds");
			}
			_maxStacks = maxStacks;
			_durationSeconds = durationSeconds;
			_clock = clock ?? throw new ArgumentNullException("clock");
		}

		public int Add(int amount = 1, bool refreshDuration = true, params int[] thresholds)
		{
			if (amount <= 0)
			{
				return Count;
			}
			Tick();
			int count = Count;
			Count = Math.Min(_maxStacks, Count + amount);
			if (refreshDuration && Count > 0)
			{
				_expiresAt = _clock.Now + _durationSeconds;
			}
			RaiseThresholds(count, Count, thresholds);
			RaiseChanged(count);
			return Count;
		}

		public void Set(int value, bool refreshDuration = true, params int[] thresholds)
		{
			Tick();
			int count = Count;
			Count = Math.Max(0, Math.Min(_maxStacks, value));
			if (refreshDuration && Count > 0)
			{
				_expiresAt = _clock.Now + _durationSeconds;
			}
			if (Count == 0)
			{
				_expiresAt = 0.0;
			}
			RaiseThresholds(count, Count, thresholds);
			RaiseChanged(count);
		}

		public void Refresh()
		{
			Tick();
			if (Count != 0)
			{
				_expiresAt = _clock.Now + _durationSeconds;
				RaiseChanged(Count);
			}
		}

		public void Clear()
		{
			if (Count != 0)
			{
				int count = Count;
				Count = 0;
				_expiresAt = 0.0;
				RaiseChanged(count);
			}
		}

		public void Tick()
		{
			if (Count != 0 && !(_clock.Now < _expiresAt))
			{
				int count = Count;
				Count = 0;
				_expiresAt = 0.0;
				RaiseChanged(count);
				this.Expired?.Invoke(this, EventArgs.Empty);
			}
		}

		private void RaiseThresholds(int previous, int current, int[] thresholds)
		{
			if (current <= previous)
			{
				return;
			}
			foreach (int num in thresholds)
			{
				if (previous < num && current >= num)
				{
					this.ThresholdReached?.Invoke(this, new ThresholdReachedEventArgs(num));
				}
			}
		}

		private void RaiseChanged(int previous)
		{
			this.Changed?.Invoke(this, new StackChangedEventArgs(previous, Count, RemainingSeconds));
		}
	}
	public sealed record StackChangedEventArgs(int Previous, int Current, double RemainingSeconds);
	public sealed record ThresholdReachedEventArgs(int Threshold);
	public sealed class WandererEnhancementState
	{
		public static WandererEnhancementState? Current { get; private set; }

		public bool IsEnhanced { get; private set; }

		public event Action<bool>? Changed;

		public WandererEnhancementState(bool registerAsCurrent = true)
		{
			if (registerAsCurrent)
			{
				Current = this;
			}
		}

		public void Set(bool enhanced)
		{
			if (IsEnhanced != enhanced)
			{
				IsEnhanced = enhanced;
				this.Changed?.Invoke(enhanced);
			}
		}

		public void Dispose()
		{
			if (Current == this)
			{
				Current = null;
			}
		}
	}
}
namespace CrestsEvolve.Core.Resources
{
	public sealed class Magazine
	{
		private readonly ResourceLedger _ledger;

		private readonly string _beadResource;

		private readonly int _capacity;

		public int Capacity => _capacity;

		public int Loaded { get; private set; }

		public Magazine(ResourceLedger ledger, string beadResource, int capacity)
		{
			_ledger = ledger ?? throw new ArgumentNullException("ledger");
			_beadResource = beadResource ?? throw new ArgumentNullException("beadResource");
			if (capacity <= 0)
			{
				throw new ArgumentOutOfRangeException("capacity");
			}
			_capacity = capacity;
		}

		public bool TryLoad()
		{
			int num = _capacity - Loaded;
			if (num <= 0)
			{
				return true;
			}
			using ResourceTransaction resourceTransaction = _ledger.Reserve(_beadResource, num, "magazine:load");
			if (!resourceTransaction.Success)
			{
				return false;
			}
			Loaded = _capacity;
			resourceTransaction.Commit();
			return true;
		}

		public bool TryConsume(int amount)
		{
			if (amount < 0)
			{
				throw new ArgumentOutOfRangeException("amount");
			}
			if (amount > Loaded)
			{
				return false;
			}
			Loaded -= amount;
			return true;
		}

		public void Unload()
		{
			if (Loaded > 0)
			{
				_ledger.Set(_beadResource, _ledger.Get(_beadResource) + Loaded);
				Loaded = 0;
			}
		}
	}
	public sealed class ResourceLedger
	{
		private readonly Dictionary<string, int> _balances = new Dictionary<string, int>(StringComparer.Ordinal);

		public int Get(string resource)
		{
			if (!_balances.TryGetValue(resource, out var value))
			{
				return 0;
			}
			return value;
		}

		public void Set(string resource, int value)
		{
			_balances[resource] = Math.Max(0, value);
		}

		public ResourceTransaction Reserve(string resource, int amount, string reason)
		{
			if (amount < 0)
			{
				throw new ArgumentOutOfRangeException("amount");
			}
			int num = Get(resource);
			if (num < amount)
			{
				return ResourceTransaction.Failed(resource, amount, reason);
			}
			_balances[resource] = num - amount;
			return new ResourceTransaction(this, resource, amount, reason, success: true);
		}

		internal void Refund(string resource, int amount)
		{
			Set(resource, Get(resource) + amount);
		}
	}
	public sealed class ResourceTransaction : IDisposable
	{
		private readonly ResourceLedger? _ledger;

		private bool _committed;

		private bool _disposed;

		public string Resource { get; }

		public int Amount { get; }

		public string Reason { get; }

		public bool Success { get; }

		internal ResourceTransaction(ResourceLedger? ledger, string resource, int amount, string reason, bool success)
		{
			_ledger = ledger;
			Resource = resource;
			Amount = amount;
			Reason = reason;
			Success = success;
		}

		public static ResourceTransaction Failed(string resource, int amount, string reason)
		{
			return new ResourceTransaction(null, resource, amount, reason, success: false);
		}

		public void Commit()
		{
			if (!Success)
			{
				throw new InvalidOperationException("Cannot commit a failed transaction.");
			}
			_committed = true;
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				_disposed = true;
				if (Success && !_committed)
				{
					_ledger.Refund(Resource, Amount);
				}
			}
		}
	}
	public sealed class VirtualToolInventory
	{
		private readonly Dictionary<string, int> _stock = new Dictionary<string, int>(StringComparer.Ordinal);

		public event Action<string, int>? ToolReplenishRequested;

		public event Action<string, int>? ToolShortage;

		public int Get(string toolId)
		{
			if (!_stock.TryGetValue(toolId, out var value))
			{
				return 0;
			}
			return value;
		}

		public void Add(string toolId, int amount)
		{
			if (string.IsNullOrWhiteSpace(toolId))
			{
				throw new ArgumentException("Tool id is required.", "toolId");
			}
			if (amount < 0)
			{
				throw new ArgumentOutOfRangeException("amount");
			}
			if (amount != 0)
			{
				_stock[toolId] = Get(toolId) + amount;
			}
		}

		public bool TryConsume(string toolId, int amount = 1)
		{
			if (string.IsNullOrWhiteSpace(toolId))
			{
				throw new ArgumentException("Tool id is required.", "toolId");
			}
			if (amount < 0)
			{
				throw new ArgumentOutOfRangeException("amount");
			}
			if (amount == 0)
			{
				return true;
			}
			int num = Get(toolId);
			if (num < amount)
			{
				this.ToolShortage?.Invoke(toolId, amount - num);
				return false;
			}
			_stock[toolId] = num - amount;
			return true;
		}

		public bool Replenish(string toolId, int targetAmount)
		{
			if (string.IsNullOrWhiteSpace(toolId))
			{
				throw new ArgumentException("Tool id is required.", "toolId");
			}
			if (targetAmount < 0)
			{
				throw new ArgumentOutOfRangeException("targetAmount");
			}
			int num = Get(toolId);
			if (num >= targetAmount)
			{
				return true;
			}
			_stock[toolId] = targetAmount;
			this.ToolReplenishRequested?.Invoke(toolId, targetAmount - num);
			return true;
		}
	}
	public sealed class VirtualToolService
	{
		private readonly ResourceLedger _ledger;

		public VirtualToolService(ResourceLedger ledger)
		{
			_ledger = ledger;
		}

		public bool TryUse(string toolId, string resource, int cost, Func<bool> invokeVanillaAction)
		{
			using ResourceTransaction resourceTransaction = _ledger.Reserve(resource, cost, "virtual-tool:" + toolId);
			if (!resourceTransaction.Success)
			{
				return false;
			}
			if (!invokeVanillaAction())
			{
				return false;
			}
			resourceTransaction.Commit();
			return true;
		}

		public bool TryUseVirtual(string toolId, VirtualToolInventory inventory, string resource, int cost, Func<bool> invokeVanillaAction)
		{
			if (inventory == null)
			{
				throw new ArgumentNullException("inventory");
			}
			if (!inventory.TryConsume(toolId))
			{
				return false;
			}
			try
			{
				using ResourceTransaction resourceTransaction = _ledger.Reserve(resource, cost, "virtual-tool:" + toolId);
				if (!resourceTransaction.Success)
				{
					inventory.Add(toolId, 1);
					return false;
				}
				if (!invokeVanillaAction())
				{
					inventory.Add(toolId, 1);
					return false;
				}
				resourceTransaction.Commit();
				return true;
			}
			catch
			{
				inventory.Add(toolId, 1);
				throw;
			}
		}
	}
}
namespace CrestsEvolve.Core.Random
{
	public interface IRandom
	{
		double NextDouble();
	}
}
namespace CrestsEvolve.Core.Input
{
	public sealed class AttackSkillWindow
	{
		private readonly IClock _clock;

		private readonly double _windowSeconds;

		private double? _attackTime;

		public double WindowSeconds => _windowSeconds;

		public bool HasPendingAttack => _attackTime.HasValue;

		public AttackSkillWindow(IClock clock, double windowSeconds)
		{
			_clock = clock ?? throw new ArgumentNullException("clock");
			if (windowSeconds <= 0.0)
			{
				throw new ArgumentOutOfRangeException("windowSeconds");
			}
			_windowSeconds = windowSeconds;
		}

		public void OnAttack()
		{
			_attackTime = _clock.Now;
		}

		public bool TryConsumeSkill()
		{
			if (!_attackTime.HasValue)
			{
				return false;
			}
			double num = _clock.Now - _attackTime.Value;
			_attackTime = null;
			if (num >= 0.0)
			{
				return num <= _windowSeconds;
			}
			return false;
		}

		public bool TryConsumeIn(double minSeconds, double maxSeconds)
		{
			if (!_attackTime.HasValue)
			{
				return false;
			}
			double num = _clock.Now - _attackTime.Value;
			if (num < minSeconds || num > maxSeconds)
			{
				return false;
			}
			_attackTime = null;
			return true;
		}

		public void Clear()
		{
			_attackTime = null;
		}

		public void Reset()
		{
			_attackTime = null;
		}
	}
	public sealed record InputSnapshot(bool Up, bool Down, bool HealPressed, bool AttackPressed, bool AttackHeld, int ChargeStage, bool InAir, bool HasControl, bool InMenuOrCutscene);
	public sealed record ChordResult(string ActionId, bool ConsumeHeal, bool ConsumeAttack);
	public sealed class InputChordRouter
	{
		private sealed record Registration(string ActionId, int Priority, Func<InputSnapshot, bool> Predicate, Func<bool> StatePredicate, bool ConsumeHeal, bool ConsumeAttack);

		private readonly List<Registration> _registrations = new List<Registration>();

		public static Func<InputSnapshot, bool> UpPlusHeal()
		{
			return (InputSnapshot s) => s.Up && s.HealPressed;
		}

		public static Func<InputSnapshot, bool> DownPlusHeal()
		{
			return (InputSnapshot s) => s.Down && s.HealPressed;
		}

		public static Func<InputSnapshot, bool> ChargePlusHeal()
		{
			return (InputSnapshot s) => s.AttackHeld && s.ChargeStage >= 1 && s.HealPressed;
		}

		public void Register(string actionId, int priority, Func<InputSnapshot, bool> predicate, Func<bool> statePredicate, bool consumeHeal = false, bool consumeAttack = false)
		{
			_registrations.Add(new Registration(actionId, priority, predicate, statePredicate, consumeHeal, consumeAttack));
			_registrations.Sort((Registration a, Registration b) => b.Priority.CompareTo(a.Priority));
		}

		public ChordResult? Resolve(InputSnapshot snapshot)
		{
			if (!snapshot.HasControl || snapshot.InMenuOrCutscene)
			{
				return null;
			}
			Registration registration = _registrations.FirstOrDefault((Registration x) => x.StatePredicate() && x.Predicate(snapshot));
			if ((object)registration != null)
			{
				return new ChordResult(registration.ActionId, registration.ConsumeHeal, registration.ConsumeAttack);
			}
			return null;
		}
	}
}
namespace CrestsEvolve.Core.Infrastructure
{
	public sealed class ServiceContainer
	{
		private readonly Dictionary<Type, object> _services = new Dictionary<Type, object>();

		public void Register<T>(T instance) where T : class
		{
			if (instance == null)
			{
				throw new ArgumentNullException("instance");
			}
			if (!_services.TryAdd(typeof(T), instance))
			{
				throw new InvalidOperationException("Service already registered: " + typeof(T).FullName);
			}
		}

		public T Get<T>() where T : class
		{
			if (_services.TryGetValue(typeof(T), out object value))
			{
				return (T)value;
			}
			throw new InvalidOperationException("Service not registered: " + typeof(T).FullName);
		}

		public T? TryGet<T>() where T : class
		{
			if (!_services.TryGetValue(typeof(T), out object value))
			{
				return null;
			}
			return (T)value;
		}
	}
}
namespace CrestsEvolve.Core.Events
{
	public sealed class GameEventHub
	{
		private readonly ManualLogSource _log;

		private readonly bool _trace;

		public Func<HealEvent, bool>? HealInterceptor { get; set; }

		public event Action<AttackEvent>? AttackResolved;

		public event Action<AttackEvent>? EnemyDamageResolved;

		public event Action<PlayerDamageEvent>? PlayerDamageBefore;

		public event Action<PlayerDamageEvent>? PlayerDamageAfter;

		public event Action<HealEvent>? HealRequested;

		public event Action<HealEvent>? HealResolved;

		public event Action<HealthChangedEvent>? HealthChanged;

		public event Action<ResourceEvent>? SilkChanged;

		public event Action<CrestChangedEvent>? CrestChanged;

		public event Action<EnemyKilledEvent>? EnemyKilled;

		public event Action? SpellKilled;

		public event Action<SkillUseEvent>? SkillUsed;

		public event Action? AttackStarted;

		public event Action? Parried;

		public event Action? DashStarted;

		public event Action? BindCompleted;

		public event Action? ToolEquipsChanged;

		public event Action<ToolUsedEvent>? ToolUsed;

		public event Action? BenchRested;

		public event Action? PlayerDied;

		public event Action<string>? SceneChanged;

		public GameEventHub(ManualLogSource log, bool trace)
		{
			_log = log;
			_trace = trace;
		}

		public void Publish(AttackEvent e)
		{
			Trace("AttackResolved", e);
			this.AttackResolved?.Invoke(e);
		}

		public void PublishEnemyDamageResolved(AttackEvent e)
		{
			Trace("EnemyDamageResolved", e);
			this.EnemyDamageResolved?.Invoke(e);
		}

		public void PublishBefore(PlayerDamageEvent e)
		{
			Trace("PlayerDamageBefore", e);
			this.PlayerDamageBefore?.Invoke(e);
		}

		public void PublishAfter(PlayerDamageEvent e)
		{
			Trace("PlayerDamageAfter", e);
			this.PlayerDamageAfter?.Invoke(e);
		}

		public void PublishRequested(HealEvent e)
		{
			Trace("HealRequested", e);
			this.HealRequested?.Invoke(e);
		}

		public void PublishResolved(HealEvent e)
		{
			Trace("HealResolved", e);
			this.HealResolved?.Invoke(e);
		}

		public void PublishHealthChanged(HealthChangedEvent e)
		{
			Trace("HealthChanged", e);
			this.HealthChanged?.Invoke(e);
		}

		public void Publish(ResourceEvent e)
		{
			Trace("SilkChanged", e);
			this.SilkChanged?.Invoke(e);
		}

		public void Publish(CrestChangedEvent e)
		{
			Trace("CrestChanged", e);
			this.CrestChanged?.Invoke(e);
		}

		public void Publish(EnemyKilledEvent e)
		{
			Trace("EnemyKilled", e);
			this.EnemyKilled?.Invoke(e);
		}

		public void PublishSpellKilled()
		{
			Trace("SpellKilled", "");
			this.SpellKilled?.Invoke();
		}

		public void Publish(SkillUseEvent e)
		{
			Trace("SkillUsed", e);
			this.SkillUsed?.Invoke(e);
		}

		public void PublishAttackStarted()
		{
			Trace("AttackStarted", "");
			this.AttackStarted?.Invoke();
		}

		public void PublishParried()
		{
			Trace("Parried", "");
			this.Parried?.Invoke();
		}

		public void PublishDashStarted()
		{
			Trace("DashStarted", "");
			this.DashStarted?.Invoke();
		}

		public void PublishBindCompleted()
		{
			Trace("BindCompleted", "");
			this.BindCompleted?.Invoke();
		}

		public void PublishToolEquipsChanged()
		{
			Trace("ToolEquipsChanged", "");
			this.ToolEquipsChanged?.Invoke();
		}

		public void PublishToolUsed(ToolUsedEvent e)
		{
			Trace("ToolUsed", e);
			this.ToolUsed?.Invoke(e);
		}

		public void PublishBenchRested()
		{
			Trace("BenchRested", "");
			this.BenchRested?.Invoke();
		}

		public void PublishPlayerDied()
		{
			Trace("PlayerDied", "");
			this.PlayerDied?.Invoke();
		}

		public void PublishSceneChanged(string scene)
		{
			Trace("SceneChanged", scene);
			this.SceneChanged?.Invoke(scene);
		}

		public bool InterceptHeal(HealEvent heal)
		{
			return HealInterceptor?.Invoke(heal) ?? false;
		}

		private void Trace(string name, object value)
		{
			if (_trace)
			{
				_log.LogDebug((object)$"[Event] {name}: {value}");
			}
		}
	}
	public sealed record PlayerDamageEvent(int MaskDamage, string SourceTag, bool Cancelled = false);
	public sealed record HealEvent(int Requested, int Applied, string SourceTag, int MissingWhiteHealth = 0);
	public sealed record HealthChangedEvent(int Previous, int Current, int MaxHealth);
	public sealed record ResourceEvent(int Previous, int Current, int Delta, string Reason);
	public sealed record CrestChangedEvent(string Previous, string Current);
	public sealed record EnemyKilledEvent(int EnemyInstanceId, string EnemyName);
	public sealed record SkillUseEvent(string SourceTag, string? ToolId = null);
	public sealed record ToolUsedEvent(string ToolName, string Binding);
}
namespace CrestsEvolve.Core.Combat
{
	public sealed class CritChanceModifier : IDamageModifier
	{
		private readonly Func<double> _chanceProvider;

		private readonly IRandom _random;

		public string Id { get; }

		public int Order { get; }

		public CritChanceModifier(string id, int order, Func<double> chanceProvider, IRandom random)
		{
			Id = id;
			Order = order;
			_chanceProvider = chanceProvider ?? throw new ArgumentNullException("chanceProvider");
			_random = random ?? throw new ArgumentNullException("random");
		}

		public bool Applies(DamageContext context)
		{
			if (!context.IsCritical)
			{
				return _chanceProvider() > 0.0;
			}
			return false;
		}

		public void Apply(DamageContext context)
		{
			double num = Math.Clamp(_chanceProvider(), 0.0, 1.0);
			if (_random.NextDouble() < num)
			{
				context.IsCritical = true;
			}
		}
	}
	public enum DamageVerdict
	{
		Allow,
		Cancel,
		AbsorbWithSilk
	}
	public sealed record DamageDecision(DamageVerdict Verdict, int RemainingMaskDamage, int SilkToSpend, string? Reason, bool ExitsEnhancement);
	public interface IDamageNegotiator
	{
		string Id { get; }

		int Priority { get; }

		DamageDecision Evaluate(int incomingMaskDamage, string sourceTag);
	}
	public sealed class DamageNegotiationService
	{
		private readonly List<IDamageNegotiator> _negotiators = new List<IDamageNegotiator>();

		public void Register(IDamageNegotiator negotiator)
		{
			if (negotiator == null)
			{
				throw new ArgumentNullException("negotiator");
			}
			if (_negotiators.Any((IDamageNegotiator x) => x.Id == negotiator.Id))
			{
				throw new InvalidOperationException("Damage negotiator already registered: " + negotiator.Id);
			}
			_negotiators.Add(negotiator);
			_negotiators.Sort((IDamageNegotiator a, IDamageNegotiator b) => b.Priority.CompareTo(a.Priority));
		}

		public DamageDecision Negotiate(int incomingMaskDamage, string sourceTag)
		{
			if (incomingMaskDamage <= 0)
			{
				return new DamageDecision(DamageVerdict.Cancel, 0, 0, "no-damage", ExitsEnhancement: false);
			}
			int num = incomingMaskDamage;
			int num2 = 0;
			string reason = null;
			bool flag = false;
			foreach (IDamageNegotiator negotiator in _negotiators)
			{
				DamageDecision damageDecision = negotiator.Evaluate(num, sourceTag);
				if (damageDecision.Verdict == DamageVerdict.Cancel && damageDecision.RemainingMaskDamage == 0)
				{
					return new DamageDecision(DamageVerdict.Cancel, 0, num2, damageDecision.Reason ?? negotiator.Id, flag);
				}
				num = Math.Max(0, damageDecision.RemainingMaskDamage);
				num2 += Math.Max(0, damageDecision.SilkToSpend);
				flag |= damageDecision.ExitsEnhancement;
				if (damageDecision.Reason != null)
				{
					reason = damageDecision.Reason;
				}
				if (num == 0)
				{
					break;
				}
			}
			if (num == 0)
			{
				return new DamageDecision((num2 <= 0) ? DamageVerdict.Cancel : DamageVerdict.AbsorbWithSilk, 0, num2, reason, flag);
			}
			return new DamageDecision(DamageVerdict.Allow, num, num2, reason, flag);
		}
	}
	public enum AttackKind
	{
		Normal,
		Dash,
		Dive,
		Charge,
		Skill,
		Tool,
		Projectile,
		Additional
	}
	public sealed record AttackEvent(long AttackId, int AttackerInstanceId, int TargetInstanceId, AttackKind Kind, string SourceTag, double BaseDamage, int HitIndex = 0, bool IsAdditionalDamage = false, bool IsHeroDamage = true, float PositionX = 0f, float PositionY = 0f, float PositionZ = 0f);
	public sealed class DamageContext
	{
		public AttackEvent Attack { get; }

		public double Damage { get; set; }

		public bool IsCritical { get; set; }

		public double CriticalMultiplier { get; set; } = 2.0;

		public List<AdditionalDamageCommand> AdditionalDamage { get; } = new List<AdditionalDamageCommand>();

		public List<DamageAuditEntry> Audit { get; } = new List<DamageAuditEntry>();

		public DamageContext(AttackEvent attack)
		{
			Attack = attack;
			Damage = attack.BaseDamage;
		}
	}
	public interface IDamageModifier
	{
		string Id { get; }

		int Order { get; }

		bool Applies(DamageContext context);

		void Apply(DamageContext context);
	}
	public sealed class DamagePipeline
	{
		private readonly List<IDamageModifier> _modifiers = new List<IDamageModifier>();

		public void Register(IDamageModifier modifier)
		{
			if (_modifiers.Any((IDamageModifier x) => x.Id == modifier.Id))
			{
				throw new InvalidOperationException("Duplicate damage modifier: " + modifier.Id);
			}
			_modifiers.Add(modifier);
			_modifiers.Sort((IDamageModifier a, IDamageModifier b) => a.Order.CompareTo(b.Order));
		}

		public DamageResult Evaluate(AttackEvent attack)
		{
			DamageContext damageContext = new DamageContext(attack);
			foreach (IDamageModifier modifier in _modifiers)
			{
				if (modifier.Applies(damageContext))
				{
					double damage = damageContext.Damage;
					modifier.Apply(damageContext);
					damageContext.Audit.Add(new DamageAuditEntry(modifier.Id, damage, damageContext.Damage));
				}
			}
			if (damageContext.IsCritical)
			{
				double damage2 = damageContext.Damage;
				damageContext.Damage *= damageContext.CriticalMultiplier;
				damageContext.Audit.Add(new DamageAuditEntry("critical", damage2, damageContext.Damage));
			}
			return new DamageResult(Math.Max(0.0, Math.Round(damageContext.Damage, MidpointRounding.AwayFromZero)), damageContext.IsCritical, damageContext.AdditionalDamage, damageContext.Audit);
		}

		public void Unregister(string modifierId)
		{
			IDamageModifier damageModifier = _modifiers.FirstOrDefault((IDamageModifier x) => x.Id == modifierId);
			if (damageModifier != null)
			{
				_modifiers.Remove(damageModifier);
			}
		}
	}
	public sealed record AdditionalDamageCommand(int TargetInstanceId, double Damage, string SourceTag, bool ReenterPipeline = false);
	public sealed record DamageAuditEntry(string ModifierId, double Before, double After);
	public sealed record DamageResult(double FinalDamage, bool IsCritical, IReadOnlyList<AdditionalDamageCommand> AdditionalDamage, IReadOnlyList<DamageAuditEntry> Audit);
	public sealed class InvulnerabilityLeaseService
	{
		private sealed record LeaseData(string Source, double ExpiresAt);

		private sealed class Lease : IDisposable
		{
			private InvulnerabilityLeaseService? _owner;

			private readonly Guid _id;

			public Lease(InvulnerabilityLeaseService owner, Guid id)
			{
				_owner = owner;
				_id = id;
			}

			public void Dispose()
			{
				_owner?.Release(_id);
				_owner = null;
			}
		}

		private readonly IClock _clock;

		private readonly Dictionary<Guid, LeaseData> _leases = new Dictionary<Guid, LeaseData>();

		public bool IsInvulnerable
		{
			get
			{
				SweepExpired();
				return _leases.Count > 0;
			}
		}

		public InvulnerabilityLeaseService(IClock clock)
		{
			_clock = clock;
		}

		public IDisposable Acquire(string source, double maxDurationSeconds)
		{
			if (string.IsNullOrWhiteSpace(source))
			{
				throw new ArgumentException("Source is required.", "source");
			}
			Guid guid = Guid.NewGuid();
			_leases[guid] = new LeaseData(source, _clock.Now + Math.Max(0.05, maxDurationSeconds));
			return new Lease(this, guid);
		}

		public IReadOnlyList<string> ActiveSources()
		{
			SweepExpired();
			return _leases.Values.Select((LeaseData x) => x.Source).ToArray();
		}

		public void ClearAll()
		{
			_leases.Clear();
		}

		private void Release(Guid id)
		{
			_leases.Remove(id);
		}

		private void SweepExpired()
		{
			double now = _clock.Now;
			Guid[] array = (from x in _leases
				where x.Value.ExpiresAt <= now
				select x.Key).ToArray();
			foreach (Guid key in array)
			{
				_leases.Remove(key);
			}
		}
	}
	public sealed class InvulnerabilityNegotiator : IDamageNegotiator
	{
		private readonly Func<bool> _isInvulnerable;

		public string Id { get; }

		public int Priority { get; }

		public InvulnerabilityNegotiator(string id, int priority, Func<bool> isInvulnerable)
		{
			Id = id;
			Priority = priority;
			_isInvulnerable = isInvulnerable ?? throw new ArgumentNullException("isInvulnerable");
		}

		public DamageDecision Evaluate(int incomingMaskDamage, string sourceTag)
		{
			if (!_isInvulnerable())
			{
				return new DamageDecision(DamageVerdict.Allow, incomingMaskDamage, 0, null, ExitsEnhancement: false);
			}
			return new DamageDecision(DamageVerdict.Cancel, 0, 0, "invulnerability-lease", ExitsEnhancement: false);
		}
	}
	public sealed class PityCritCounter
	{
		public int ConsecutiveNonCrits { get; private set; }

		public bool ShouldGuarantee(int threshold)
		{
			if (threshold > 0)
			{
				return ConsecutiveNonCrits + 1 >= threshold;
			}
			return false;
		}

		public void Record(bool wasCrit)
		{
			ConsecutiveNonCrits = ((!wasCrit) ? (ConsecutiveNonCrits + 1) : 0);
		}

		public void Reset()
		{
			ConsecutiveNonCrits = 0;
		}
	}
	public sealed class PityCritModifier : IDamageModifier
	{
		private readonly PityCritCounter _counter;

		private readonly int _threshold;

		public string Id { get; }

		public int Order { get; }

		public PityCritModifier(string id, int order, PityCritCounter counter, int threshold)
		{
			Id = id;
			Order = order;
			_counter = counter;
			_threshold = threshold;
		}

		public bool Applies(DamageContext context)
		{
			if (!context.IsCritical)
			{
				return _counter.ShouldGuarantee(_threshold);
			}
			return false;
		}

		public void Apply(DamageContext context)
		{
			context.IsCritical = true;
		}
	}
	public sealed class SilkShieldNegotiator : IDamageNegotiator
	{
		private readonly SilkShieldPolicy _policy;

		private readonly Func<bool> _isActive;

		private readonly Func<int> _currentSilk;

		private readonly Func<int> _silkPerMask;

		public string Id { get; }

		public int Priority { get; }

		public SilkShieldNegotiator(string id, int priority, SilkShieldPolicy policy, Func<bool> isActive, Func<int> currentSilk, Func<int> silkPerMask)
		{
			Id = id;
			Priority = priority;
			_policy = policy ?? throw new ArgumentNullException("policy");
			_isActive = isActive ?? throw new ArgumentNullException("isActive");
			_currentSilk = currentSilk ?? throw new ArgumentNullException("currentSilk");
			_silkPerMask = silkPerMask ?? throw new ArgumentNullException("silkPerMask");
		}

		public DamageDecision Evaluate(int incomingMaskDamage, string sourceTag)
		{
			if (!_isActive())
			{
				return new DamageDecision(DamageVerdict.Allow, incomingMaskDamage, 0, null, ExitsEnhancement: false);
			}
			SilkShieldResult silkShieldResult = _policy.Resolve(incomingMaskDamage, _currentSilk(), _silkPerMask());
			return new DamageDecision((silkShieldResult.RemainingMaskDamage <= 0) ? DamageVerdict.AbsorbWithSilk : DamageVerdict.Allow, silkShieldResult.RemainingMaskDamage, silkShieldResult.SilkSpent, "silk-shield", silkShieldResult.ShouldExitEnhancement);
		}
	}
	public sealed class SilkShieldPolicy
	{
		public SilkShieldResult Resolve(int incomingMaskDamage, int currentSilk, int silkPerMask = 3)
		{
			if (incomingMaskDamage < 0)
			{
				throw new ArgumentOutOfRangeException("incomingMaskDamage");
			}
			if (currentSilk < 0)
			{
				throw new ArgumentOutOfRangeException("currentSilk");
			}
			if (silkPerMask <= 0)
			{
				throw new ArgumentOutOfRangeException("silkPerMask");
			}
			int num = Math.Min(incomingMaskDamage, currentSilk / silkPerMask);
			int silkSpent = num * silkPerMask;
			int num2 = incomingMaskDamage - num;
			bool flag = num2 == 0;
			return new SilkShieldResult(num, silkSpent, num2, !flag);
		}
	}
	public sealed record SilkShieldResult(int AbsorbedMaskDamage, int SilkSpent, int RemainingMaskDamage, bool ShouldExitEnhancement);
	public sealed class SilkShieldStateService
	{
		private string? _source;

		public bool IsActive { get; private set; }

		public string? Source => _source;

		public void SetActive(bool active, string source)
		{
			if (active && string.IsNullOrWhiteSpace(source))
			{
				throw new ArgumentException("Source is required when activating.", "source");
			}
			IsActive = active;
			_source = (active ? source : null);
		}
	}
}
namespace CrestsEvolve.Core.Charms
{
	public interface ICharmEnhancementContext
	{
		bool IsEnhanced { get; set; }

		int TemporaryLevelOffset { get; set; }
	}
	public sealed class CharmEnhancementContext : ICharmEnhancementContext
	{
		public bool IsEnhanced { get; set; }

		public int TemporaryLevelOffset { get; set; }
	}
	public interface ICharmEnhancement
	{
		string CharmId { get; }

		void Apply(ICharmEnhancementContext context);

		void Revert(ICharmEnhancementContext context);
	}
	public sealed class CharmEnhancementRegistry
	{
		private readonly Dictionary<string, ICharmEnhancement> _enhancements = new Dictionary<string, ICharmEnhancement>(StringComparer.Ordinal);

		private readonly List<string> _active = new List<string>();

		public IReadOnlyList<string> ActiveCharmIds => _active;

		public void Register(ICharmEnhancement enhancement)
		{
			if (enhancement == null)
			{
				throw new ArgumentNullException("enhancement");
			}
			if (!_enhancements.TryAdd(enhancement.CharmId, enhancement))
			{
				throw new InvalidOperationException("Charm enhancement already registered: " + enhancement.CharmId);
			}
		}

		public void Register(IEnumerable<ICharmEnhancement> enhancements)
		{
			foreach (ICharmEnhancement enhancement in enhancements)
			{
				Register(enhancement);
			}
		}

		public bool IsRegistered(string charmId)
		{
			return _enhancements.ContainsKey(charmId);
		}

		public bool TryGet(string charmId, out ICharmEnhancement enhancement)
		{
			return _enhancements.TryGetValue(charmId, out enhancement);
		}

		public void Activate(string charmId, ICharmEnhancementContext context)
		{
			if (!_enhancements.TryGetValue(charmId, out ICharmEnhancement value))
			{
				throw new KeyNotFoundException("Charm enhancement not registered: " + charmId);
			}
			if (!_active.Contains(charmId))
			{
				_active.Add(charmId);
				value.Apply(context);
			}
		}

		public void Deactivate(string charmId, ICharmEnhancementContext context)
		{
			if (_enhancements.TryGetValue(charmId, out ICharmEnhancement value) && _active.Remove(charmId))
			{
				value.Revert(context);
			}
		}

		public void DeactivateAll(ICharmEnhancementContext context)
		{
			string[] array = _active.ToArray();
			foreach (string charmId in array)
			{
				Deactivate(charmId, context);
			}
		}
	}
	public sealed record CharmSlotState(string CrestId, string SlotA, string SlotB)
	{
		public bool IsEmpty
		{
			get
			{
				if (string.IsNullOrWhiteSpace(SlotA))
				{
					return string.IsNullOrWhiteSpace(SlotB);
				}
				return false;
			}
		}
	}
	public sealed class SpecialCharmSlots
	{
		private string? _slotA;

		private string? _slotB;

		public CharmSlotState Current { get; private set; } = new CharmSlotState("none", "", "");

		public void Set(string crestId, string? slotA, string? slotB)
		{
			if (string.IsNullOrWhiteSpace(crestId))
			{
				throw new ArgumentException("CrestId is required.", "crestId");
			}
			_slotA = (string.IsNullOrWhiteSpace(slotA) ? null : slotA);
			_slotB = (string.IsNullOrWhiteSpace(slotB) ? null : slotB);
			Current = new CharmSlotState(crestId, _slotA ?? "", _slotB ?? "");
		}

		public void Clear()
		{
			Set("none", null, null);
		}
	}
	public interface ITemporaryCharmLevelProjection
	{
		int CurrentOffset { get; }

		void SetOffset(int offset, string source);
	}
	public sealed class InMemoryCharmLevelProjection : ITemporaryCharmLevelProjection
	{
		public int CurrentOffset { get; private set; }

		public string? Source { get; private set; }

		public void SetOffset(int offset, string source)
		{
			CurrentOffset = Math.Max(0, offset);
			Source = source;
		}
	}
	public sealed class DiceCharmEnhancement : ICharmEnhancement
	{
		public const string DiceCharmId = "dice";

		private readonly Func<int> _levelProvider;

		private readonly Func<bool> _enhancedProvider;

		private readonly HunterBalanceOptions _balance;

		private readonly DamagePipeline _pipeline;

		private readonly IRandom _random;

		private CritChanceModifier? _modifier;

		private bool _applied;

		public string CharmId => "dice";

		public DiceCharmEnhancement(Func<int> levelProvider, Func<bool> enhancedProvider, HunterBalanceOptions balance, DamagePipeline pipeline, IRandom random)
		{
			_levelProvider = levelProvider ?? throw new ArgumentNullException("levelProvider");
			_enhancedProvider = enhancedProvider ?? throw new ArgumentNullException("enhancedProvider");
			_balance = balance ?? throw new ArgumentNullException("balance");
			_pipeline = pipeline ?? throw new ArgumentNullException("pipeline");
			_random = random ?? throw new ArgumentNullException("random");
		}

		public void Apply(ICharmEnhancementContext context)
		{
			if (!_applied)
			{
				_applied = true;
				_modifier = new CritChanceModifier("charm.dice.crit", 1000, ComputeChance, _random);
				_pipeline.Register(_modifier);
			}
		}

		public void Revert(ICharmEnhancementContext context)
		{
			if (_applied)
			{
				_applied = false;
				if (_modifier != null)
				{
					_pipeline.Unregister(_modifier.Id);
					_modifier = null;
				}
			}
		}

		private double ComputeChance()
		{
			int num = Math.Clamp(_levelProvider(), 1, 3);
			double num2 = num switch
			{
				1 => _balance.DiceCritChanceL1, 
				2 => _balance.DiceCritChanceL2, 
				_ => _balance.DiceCritChanceL3, 
			};
			if (!_enhancedProvider())
			{
				return Math.Clamp(num2, 0.0, 1.0);
			}
			double num3 = ((num != 1) ? _balance.EnhancedDiceCritBonusL2 : _balance.EnhancedDiceCritBonusL1);
			double num4 = num3;
			return Math.Clamp(num2 + num4, 0.0, 1.0);
		}
	}
}
namespace CrestsEvolve.Core.Buffs
{
	public enum BuffKind
	{
		Fire,
		Poison,
		Meade
	}
	public sealed class BuffState
	{
		private readonly IClock _clock;

		private readonly int _maxStacks;

		private readonly double _durationSeconds;

		private double _expiresAt;

		public BuffKind Kind { get; }

		public int Stacks { get; private set; }

		public bool IsActive
		{
			get
			{
				if (Stacks > 0)
				{
					return RemainingSeconds > 0.0;
				}
				return false;
			}
		}

		public double RemainingSeconds
		{
			get
			{
				if (Stacks != 0)
				{
					return Math.Max(0.0, _expiresAt - _clock.Now);
				}
				return 0.0;
			}
		}

		public BuffState(BuffKind kind, int maxStacks, double durationSeconds, IClock clock)
		{
			if (maxStacks <= 0)
			{
				throw new ArgumentOutOfRangeException("maxStacks");
			}
			if (durationSeconds <= 0.0)
			{
				throw new ArgumentOutOfRangeException("durationSeconds");
			}
			Kind = kind;
			_maxStacks = maxStacks;
			_durationSeconds = durationSeconds;
			_clock = clock ?? throw new ArgumentNullException("clock");
		}

		public void Add(int stacks = 1, bool refreshDuration = true)
		{
			if (stacks > 0)
			{
				Tick();
				Stacks = Math.Min(_maxStacks, Stacks + stacks);
				if (refreshDuration && Stacks > 0)
				{
					_expiresAt = _clock.Now + _durationSeconds;
				}
			}
		}

		public bool Consume(int stacks = 1)
		{
			if (stacks <= 0 || !IsActive)
			{
				return false;
			}
			Stacks = Math.Max(0, Stacks - stacks);
			if (Stacks == 0)
			{
				_expiresAt = 0.0;
			}
			return true;
		}

		public void Tick()
		{
			if (Stacks != 0 && !(_clock.Now < _expiresAt))
			{
				Stacks = 0;
				_expiresAt = 0.0;
			}
		}

		public void Clear()
		{
			Stacks = 0;
			_expiresAt = 0.0;
		}
	}
}
namespace CrestsEvolve.Core.Balance
{
	public sealed record HunterBalanceOptions(bool Enabled, double StackDurationSeconds, int Level2Threshold, int Level3Threshold, int Level2CharmOffset, int Level3CharmOffset, int RageMinStacks, int SuperRageHitsPerBonus, double SuperRageFlatDamagePerBonus, double SuperRageDurationSeconds, double DashAttackRangeMultiplier, bool DashAttackPierce, double DashInvulnerabilitySeconds, double DiceCritChanceL1, double DiceCritChanceL2, double DiceCritChanceL3, double EnhancedDiceCritBonusL1, double EnhancedDiceCritBonusL2)
	{
		public static HunterBalanceOptions Defaults { get; } = new HunterBalanceOptions(Enabled: true, 10.0, 6, 12, 1, 2, 6, 6, 5.0, 10.0, 1.0, DashAttackPierce: true, 0.1, 0.03, 0.05, 0.07, 0.01, 0.02);

		public IReadOnlyList<string> Validate()
		{
			List<string> list = new List<string>();
			if (StackDurationSeconds <= 0.0)
			{
				list.Add("Hunter.StackDurationSeconds must be > 0");
			}
			if (Level2Threshold <= 0)
			{
				list.Add("Hunter.Level2Threshold must be > 0");
			}
			if (Level3Threshold <= Level2Threshold)
			{
				list.Add("Hunter.Level3Threshold must be > Level2Threshold");
			}
			if (Level3Threshold > 12)
			{
				list.Add("Hunter.Level3Threshold must be <= 12");
			}
			if (Level2CharmOffset < 0)
			{
				list.Add("Hunter.Level2CharmOffset must be >= 0");
			}
			if (Level3CharmOffset < 0)
			{
				list.Add("Hunter.Level3CharmOffset must be >= 0");
			}
			if (RageMinStacks <= 0)
			{
				list.Add("Hunter.RageMinStacks must be > 0");
			}
			if (SuperRageHitsPerBonus <= 0)
			{
				list.Add("Hunter.SuperRageHitsPerBonus must be > 0");
			}
			if (SuperRageFlatDamagePerBonus < 0.0)
			{
				list.Add("Hunter.SuperRageFlatDamagePerBonus must be >= 0");
			}
			if (SuperRageDurationSeconds <= 0.0)
			{
				list.Add("Hunter.SuperRageDurationSeconds must be > 0");
			}
			if (DashAttackRangeMultiplier <= 0.0)
			{
				list.Add("Hunter.DashAttackRangeMultiplier must be > 0");
			}
			if (DashInvulnerabilitySeconds < 0.0)
			{
				list.Add("Hunter.DashInvulnerabilitySeconds must be >= 0");
			}
			double diceCritChanceL = DiceCritChanceL1;
			if ((diceCritChanceL < 0.0 || diceCritChanceL > 1.0) ? true : false)
			{
				list.Add("Hunter.DiceCritChanceL1 must be in [0,1]");
			}
			diceCritChanceL = DiceCritChanceL2;
			if ((diceCritChanceL < 0.0 || diceCritChanceL > 1.0) ? true : false)
			{
				list.Add("Hunter.DiceCritChanceL2 must be in [0,1]");
			}
			diceCritChanceL = DiceCritChanceL3;
			if ((diceCritChanceL < 0.0 || diceCritChanceL > 1.0) ? true : false)
			{
				list.Add("Hunter.DiceCritChanceL3 must be in [0,1]");
			}
			if (EnhancedDiceCritBonusL1 < 0.0)
			{
				list.Add("Hunter.EnhancedDiceCritBonusL1 must be >= 0");
			}
			if (EnhancedDiceCritBonusL2 < 0.0)
			{
				list.Add("Hunter.EnhancedDiceCritBonusL2 must be >= 0");
			}
			return list;
		}

		[CompilerGenerated]
		private HunterBalanceOptions(HunterBalanceOptions original)
		{
			Enabled = original.Enabled;
			StackDurationSeconds = original.StackDurationSeconds;
			Level2Threshold = original.Level2Threshold;
			Level3Threshold = original.Level3Threshold;
			Level2CharmOffset = original.Level2CharmOffset;
			Level3CharmOffset = original.Level3CharmOffset;
			RageMinStacks = original.RageMinStacks;
			SuperRageHitsPerBonus = original.SuperRageHitsPerBonus;
			SuperRageFlatDamagePerBonus = original.SuperRageFlatDamagePerBonus;
			SuperRageDurationSeconds = original.SuperRageDurationSeconds;
			DashAttackRangeMultiplier = original.DashAttackRangeMultiplier;
			DashAttackPierce = original.DashAttackPierce;
			DashInvulnerabilitySeconds = original.DashInvulnerabilitySeconds;
			DiceCritChanceL1 = original.DiceCritChanceL1;
			DiceCritChanceL2 = original.DiceCritChanceL2;
			DiceCritChanceL3 = original.DiceCritChanceL3;
			EnhancedDiceCritBonusL1 = original.EnhancedDiceCritBonusL1;
			EnhancedDiceCritBonusL2 = original.EnhancedDiceCritBonusL2;
		}
	}
	public sealed record SilkMotherBalanceOptions(bool Enabled, int MaxStage, int StageCostSilk, int SilkPerMaskDamage, int SilkCapWhileEnhanced, int MinimumSilkToEnter)
	{
		public static SilkMotherBalanceOptions Defaults { get; } = new SilkMotherBalanceOptions(Enabled: true, 12, 9, 3, 99, 9);

		public IReadOnlyList<string> Validate()
		{
			List<string> list = new List<string>();
			int maxStage = MaxStage;
			if ((maxStage < 1 || maxStage > 99) ? true : false)
			{
				list.Add("SilkMother.MaxStage must be in [1,99]");
			}
			if (StageCostSilk <= 0)
			{
				list.Add("SilkMother.StageCostSilk must be > 0");
			}
			if (SilkPerMaskDamage <= 0)
			{
				list.Add("SilkMother.SilkPerMaskDamage must be > 0");
			}
			if (MinimumSilkToEnter <= 0)
			{
				list.Add("SilkMother.MinimumSilkToEnter must be > 0");
			}
			if (SilkCapWhileEnhanced < MinimumSilkToEnter)
			{
				list.Add("SilkMother.SilkCapWhileEnhanced must be >= MinimumSilkToEnter");
			}
			return list;
		}

		[CompilerGenerated]
		private SilkMotherBalanceOptions(SilkMotherBalanceOptions original)
		{
			Enabled = original.Enabled;
			MaxStage = original.MaxStage;
			StageCostSilk = original.StageCostSilk;
			SilkPerMaskDamage = original.SilkPerMaskDamage;
			SilkCapWhileEnhanced = original.SilkCapWhileEnhanced;
			MinimumSilkToEnter = original.MinimumSilkToEnter;
		}
	}
	public sealed record SafetyOptions(double MaxCriticalChance, double MaxDamageMultiplier, int MaxAdditionalDamageDepth, double MaxInvulnerabilityLeaseSeconds)
	{
		public static SafetyOptions Defaults { get; } = new SafetyOptions(1.0, 50.0, 1, 10.0);

		public IReadOnlyList<string> Validate()
		{
			List<string> list = new List<string>();
			double maxCriticalChance = MaxCriticalChance;
			if ((maxCriticalChance <= 0.0 || maxCriticalChance > 1.0) ? true : false)
			{
				list.Add("Safety.MaxCriticalChance must be in (0,1]");
			}
			if (MaxDamageMultiplier < 1.0)
			{
				list.Add("Safety.MaxDamageMultiplier must be >= 1");
			}
			if (MaxAdditionalDamageDepth < 0)
			{
				list.Add("Safety.MaxAdditionalDamageDepth must be >= 0");
			}
			if (MaxInvulnerabilityLeaseSeconds <= 0.0)
			{
				list.Add("Safety.MaxInvulnerabilityLeaseSeconds must be > 0");
			}
			return list;
		}

		[CompilerGenerated]
		private SafetyOptions(SafetyOptions original)
		{
			MaxCriticalChance = original.MaxCriticalChance;
			MaxDamageMultiplier = original.MaxDamageMultiplier;
			MaxAdditionalDamageDepth = original.MaxAdditionalDamageDepth;
			MaxInvulnerabilityLeaseSeconds = original.MaxInvulnerabilityLeaseSeconds;
		}
	}
	public sealed record ToolBalanceOptions(bool Enabled, int MagazineCapacity, int ToolReplenishTarget, ToolUpgradeBalanceOptions Upgrades)
	{
		public static ToolBalanceOptions Defaults { get; } = new ToolBalanceOptions(Enabled: true, 80, 1, ToolUpgradeBalanceOptions.Defaults);

		public IReadOnlyList<string> Validate()
		{
			List<string> list = new List<string>();
			if (MagazineCapacity <= 0)
			{
				list.Add("Tools.MagazineCapacity must be > 0");
			}
			if (ToolReplenishTarget < 0)
			{
				list.Add("Tools.ToolReplenishTarget must be >= 0");
			}
			list.AddRange(Upgrades.Validate());
			return list;
		}

		[CompilerGenerated]
		private ToolBalanceOptions(ToolBalanceOptions original)
		{
			Enabled = original.Enabled;
			MagazineCapacity = original.MagazineCapacity;
			ToolReplenishTarget = original.ToolReplenishTarget;
			Upgrades = original.Upgrades;
		}
	}
	public sealed record RageBalanceOptions(bool Enabled, double SuperRageDurationSeconds, int AttacksPerBonus, bool AutoSuperRageEnabled, bool ResetBonusOnDamage, double WandererDamageMultiplier, double WitchDashDamageMultiplier, double WitchSawbladeCritChance, string WitchSawbladeToolId, double ArchitectToolDamageMultiplier, double ShamanCritChance, int ShamanWaveSilkPerHit, double WandererSuperRageCritPerBonus, double ReaperExplosionDamageMultiplier, double ReaperExplosionRadius, int WitchDashSilkPerHit, double WitchSuperRageBindDamageMultiplier, double WitchSuperRageBindRangeMultiplier, int ArchitectToolSilkPerHit, double CursedSkillDamageMultiplier, double CloaklessBlockChance, double CloaklessCritChance, int ShamanSkillCostReduction, int HunterSilkPerHit, int HunterFocusThresholdRage, int HunterFocusThresholdSuperRage, int ReaperSilkOrbPartsMultiplier, double WandererCritDamageMultiplier, double WandererKnockbackMultiplier, double BeastAttackRangeMultiplier, double BeastAttackDamageMultiplier, double BeastAttackSpeedBonus, int WitchMultiHitSilkPerHit, double WitchSuperRageMultiHitDamageMultiplier)
	{
		public static RageBalanceOptions Defaults { get; } = new RageBalanceOptions(Enabled: true, 10.0, 6, AutoSuperRageEnabled: true, ResetBonusOnDamage: false, 1.75, 1.0, 0.1, "Brolly Spike", 1.75, 0.1, 1, 0.02, 1.0, 3.0, 1, 2.0, 2.0, 1, 1.75, 0.8, 0.8, 1, 1, 6, 12, 3, 2.0, 2.0, 1.25, 1.25, 0.18, 1, 2.0);

		public IReadOnlyList<string> Validate()
		{
			List<string> list = new List<string>();
			if (SuperRageDurationSeconds <= 0.0)
			{
				list.Add("Rage.SuperRageDurationSeconds must be > 0");
			}
			if (AttacksPerBonus <= 0)
			{
				list.Add("Rage.AttacksPerBonus must be > 0");
			}
			if (WandererDamageMultiplier <= 0.0)
			{
				list.Add("Rage.WandererDamageMultiplier must be > 0");
			}
			if (WitchDashDamageMultiplier <= 0.0)
			{
				list.Add("Rage.WitchDashDamageMultiplier must be > 0");
			}
			if (WitchSawbladeCritChance < 0.0 || WitchSawbladeCritChance > 1.0)
			{
				list.Add("Rage.WitchSawbladeCritChance must be in [0,1]");
			}
			if (string.IsNullOrWhiteSpace(WitchSawbladeToolId))
			{
				list.Add("Rage.WitchSawbladeToolId must not be empty");
			}
			if (ArchitectToolDamageMultiplier <= 0.0)
			{
				list.Add("Rage.ArchitectToolDamageMultiplier must be > 0");
			}
			if (ShamanCritChance < 0.0 || ShamanCritChance > 1.0)
			{
				list.Add("Rage.ShamanCritChance must be in [0,1]");
			}
			if (ShamanWaveSilkPerHit <= 0)
			{
				list.Add("Rage.ShamanWaveSilkPerHit must be > 0");
			}
			if (WandererSuperRageCritPerBonus < 0.0 || WandererSuperRageCritPerBonus > 1.0)
			{
				list.Add("Rage.WandererSuperRageCritPerBonus must be in [0,1]");
			}
			if (ReaperExplosionDamageMultiplier <= 0.0)
			{
				list.Add("Rage.ReaperExplosionDamageMultiplier must be > 0");
			}
			if (ReaperExplosionRadius <= 0.0)
			{
				list.Add("Rage.ReaperExplosionRadius must be > 0");
			}
			if (WitchDashSilkPerHit <= 0)
			{
				list.Add("Rage.WitchDashSilkPerHit must be > 0");
			}
			if (WitchSuperRageBindDamageMultiplier <= 0.0)
			{
				list.Add("Rage.WitchSuperRageBindDamageMultiplier must be > 0");
			}
			if (WitchSuperRageBindRangeMultiplier <= 0.0)
			{
				list.Add("Rage.WitchSuperRageBindRangeMultiplier must be > 0");
			}
			if (ArchitectToolSilkPerHit <= 0)
			{
				list.Add("Rage.ArchitectToolSilkPerHit must be > 0");
			}
			if (CursedSkillDamageMultiplier <= 0.0)
			{
				list.Add("Rage.CursedSkillDamageMultiplier must be > 0");
			}
			double cloaklessBlockChance = CloaklessBlockChance;
			if ((cloaklessBlockChance < 0.0 || cloaklessBlockChance > 1.0) ? true : false)
			{
				list.Add("Rage.CloaklessBlockChance must be in [0,1]");
			}
			cloaklessBlockChance = CloaklessCritChance;
			if ((cloaklessBlockChance < 0.0 || cloaklessBlockChance > 1.0) ? true : false)
			{
				list.Add("Rage.CloaklessCritChance must be in [0,1]");
			}
			if (ShamanSkillCostReduction < 0)
			{
				list.Add("Rage.ShamanSkillCostReduction must be >= 0");
			}
			if (HunterSilkPerHit <= 0)
			{
				list.Add("Rage.HunterSilkPerHit must be > 0");
			}
			if (HunterFocusThresholdRage <= 0)
			{
				list.Add("Rage.HunterFocusThresholdRage must be > 0");
			}
			if (HunterFocusThresholdSuperRage <= 0)
			{
				list.Add("Rage.HunterFocusThresholdSuperRage must be > 0");
			}
			if (ReaperSilkOrbPartsMultiplier <= 0)
			{
				list.Add("Rage.ReaperSilkOrbPartsMultiplier must be > 0");
			}
			if (WandererCritDamageMultiplier <= 0.0)
			{
				list.Add("Rage.WandererCritDamageMultiplier must be > 0");
			}
			if (WandererKnockbackMultiplier <= 0.0)
			{
				list.Add("Rage.WandererKnockbackMultiplier must be > 0");
			}
			if (BeastAttackRangeMultiplier <= 0.0)
			{
				list.Add("Rage.BeastAttackRangeMultiplier must be > 0");
			}
			if (BeastAttackDamageMultiplier <= 0.0)
			{
				list.Add("Rage.BeastAttackDamageMultiplier must be > 0");
			}
			if (BeastAttackSpeedBonus < 0.0)
			{
				list.Add("Rage.BeastAttackSpeedBonus must be >= 0");
			}
			if (WitchMultiHitSilkPerHit <= 0)
			{
				list.Add("Rage.WitchMultiHitSilkPerHit must be > 0");
			}
			if (WitchSuperRageMultiHitDamageMultiplier <= 0.0)
			{
				list.Add("Rage.WitchSuperRageMultiHitDamageMultiplier must be > 0");
			}
			return list;
		}

		[CompilerGenerated]
		private RageBalanceOptions(RageBalanceOptions original)
		{
			Enabled = original.Enabled;
			SuperRageDurationSeconds = original.SuperRageDurationSeconds;
			AttacksPerBonus = original.AttacksPerBonus;
			AutoSuperRageEnabled = original.AutoSuperRageEnabled;
			ResetBonusOnDamage = original.ResetBonusOnDamage;
			WandererDamageMultiplier = original.WandererDamageMultiplier;
			WitchDashDamageMultiplier = original.WitchDashDamageMultiplier;
			WitchSawbladeCritChance = original.WitchSawbladeCritChance;
			WitchSawbladeToolId = original.WitchSawbladeToolId;
			ArchitectToolDamageMultiplier = original.ArchitectToolDamageMultiplier;
			ShamanCritChance = original.ShamanCritChance;
			ShamanWaveSilkPerHit = original.ShamanWaveSilkPerHit;
			WandererSuperRageCritPerBonus = original.WandererSuperRageCritPerBonus;
			ReaperExplosionDamageMultiplier = original.ReaperExplosionDamageMultiplier;
			ReaperExplosionRadius = original.ReaperExplosionRadius;
			WitchDashSilkPerHit = original.WitchDashSilkPerHit;
			WitchSuperRageBindDamageMultiplier = original.WitchSuperRageBindDamageMultiplier;
			WitchSuperRageBindRangeMultiplier = original.WitchSuperRageBindRangeMultiplier;
			ArchitectToolSilkPerHit = original.ArchitectToolSilkPerHit;
			CursedSkillDamageMultiplier = original.CursedSkillDamageMultiplier;
			CloaklessBlockChance = original.CloaklessBlockChance;
			CloaklessCritChance = original.CloaklessCritChance;
			ShamanSkillCostReduction = original.ShamanSkillCostReduction;
			HunterSilkPerHit = original.HunterSilkPerHit;
			HunterFocusThresholdRage = original.HunterFocusThresholdRage;
			HunterFocusThresholdSuperRage = original.HunterFocusThresholdSuperRage;
			ReaperSilkOrbPartsMultiplier = original.ReaperSilkOrbPartsMultiplier;
			WandererCritDamageMultiplier = original.WandererCritDamageMultiplier;
			WandererKnockbackMultiplier = original.WandererKnockbackMultiplier;
			BeastAttackRangeMultiplier = original.BeastAttackRangeMultiplier;
			BeastAttackDamageMultiplier = original.BeastAttackDamageMultiplier;
			BeastAttackSpeedBonus = original.BeastAttackSpeedBonus;
			WitchMultiHitSilkPerHit = original.WitchMultiHitSilkPerHit;
			WitchSuperRageMultiHitDamageMultiplier = original.WitchSuperRageMultiHitDamageMultiplier;
		}
	}
	public sealed record BalanceOptions(HunterBalanceOptions Hunter, SilkMotherBalanceOptions SilkMother, SafetyOptions Safety, ToolBalanceOptions Tools, RageBalanceOptions Rage)
	{
		public static BalanceOptions Defaults { get; } = new BalanceOptions(HunterBalanceOptions.Defaults, SilkMotherBalanceOptions.Defaults, SafetyOptions.Defaults, ToolBalanceOptions.Defaults, RageBalanceOptions.Defaults);

		public IReadOnlyList<string> Validate()
		{
			List<string> list = new List<string>();
			list.AddRange(Hunter.Validate());
			list.AddRange(SilkMother.Validate());
			list.AddRange(Safety.Validate());
			list.AddRange(Tools.Validate());
			list.AddRange(Rage.Validate());
			return list;
		}

		[CompilerGenerated]
		private BalanceOptions(BalanceOptions original)
		{
			Hunter = original.Hunter;
			SilkMother = original.SilkMother;
			Safety = original.Safety;
			Tools = original.Tools;
			Rage = original.Rage;
		}
	}
}
namespace CrestsEvolve.Bootstrap
{
	public sealed class ModBootstrap : IDisposable
	{
		private readonly ManualLogSource _log;

		private readonly ConfigFile _config;

		private readonly Harmony _harmony;

		private FeatureRuntime? _runtime;

		private IGameApi? _game;

		private GameEventHub? _events;

		private GameEventPatches? _eventPatches;

		private StatusIconLedger? _statusLedger;

		private StatusIconProjector? _statusProjector;

		private StatusIconFeature? _statusIcons;

		private GameObject? _skillSignalGo;

		private GameObject? _tickRunnerGo;

		private StatusIconTickRunner? _tickRunner;

		private FoundationServices? _services;

		private MethodBase? _slotTypeGetter;

		private MethodBase? _crestHasSlotMethod;

		private MethodBase? _startSelectionMethod;

		private MethodBase? _endSelectionMethod;

		private MethodBase? _slotSetEquippedMethod;

		private MethodBase? _placeToolMethod;

		private MethodBase? _isSlotInvalidMethod;

		private MethodBase? _refreshToolsMethod;

		private MethodBase? _toolUpdateEquippedDisplayMethod;

		private MethodBase? _setEquippedCrestMethod;

		private MethodBase? _languageGetMethod;

		public FoundationServices? Services => _services;

		public ModBootstrap(ManualLogSource log, ConfigFile config, Harmony harmony)
		{
			_log = log;
			_config = config;
			_harmony = harmony;
		}

		public void Start()
		{
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0474: Expected O, but got Unknown
			ConfigEntry<bool> obj = _config.Bind<bool>("General", "Enabled", true, "Master switch.");
			ConfigEntry<bool> val = _config.Bind<bool>("Debug", "TraceEvents", false, "Verbose combat event logging.");
			ConfigEntry<bool> val2 = _config.Bind<bool>("Debug", "StatusIconSnapshotLogging", false, "Log full status-icon snapshots on every revision (heavy; keep false).");
			ToolEquipsDiagnostics.Enabled = _config.Bind<bool>("Debug", "ToolEquipsDiagnostics", false, "Log per-crest ToolEquips snapshots around quick switching and inventory crest selection (diagnostic; keep false).").Value;
			if (!obj.Value)
			{
				_log.LogInfo((object)"CrestsEvolve (foundation) is disabled by configuration.");
				return;
			}
			ServiceContainer serviceContainer = new ServiceContainer();
			GameEventHub gameEventHub = (_events = new GameEventHub(_log, val.Value));
			UnityClock unityClock = new UnityClock();
			InvulnerabilityLeaseService leaseService = new InvulnerabilityLeaseService(unityClock);
			GameBindingConfig gameBindingConfig = GameBindingConfig.LoadOrCreate(_log);
			DynamicPatchResolver dynamicPatchResolver = new DynamicPatchResolver(_log, gameBindingConfig);
			ReaperStateAccessor reaperState = new ReaperStateAccessor(_log, dynamicPatchResolver);
			BeastStateAccessor beastState = new BeastStateAccessor(_log);
			HunterStateAccessor hunterState = new HunterStateAccessor(_log);
			DashStateAccessor dashState = new DashStateAccessor(_log);
			ReflectionGameApi game = new ReflectionGameApi(_log, gameEventHub, dynamicPatchResolver, leaseService);
			_game = game;
			LogUiPresenter logUiPresenter = new LogUiPresenter(_log);
			NeedleforgeAdapter needleforgeAdapter = new NeedleforgeAdapter(_log);
			StatusIconOptions statusIconOptions = StatusIconBinder.Bind(_config, _log);
			BalanceOptions balance = BalanceBinder.Bind(_config, _log);
			StatusIconLedger statusIconLedger = new StatusIconLedger();
			StatusIconTextureService statusTextures = new StatusIconTextureService(_log, statusIconOptions);
			LogStatusIconPresenter.Verbose = val2.Value;
			LogUiPresenter.Verbose = val2.Value;
			CompositeStatusIconPresenter presenter = new CompositeStatusIconPresenter(new LogStatusIconPresenter(_log), () => HudStatusIconHost.Instance);
			StatusIconProjector statusProjector = new StatusIconProjector(statusIconLedger, presenter);
			StatusIconFeature statusIconFeature = new StatusIconFeature(_log, statusIconLedger, statusIconOptions);
			DamagePipeline damagePipeline = new DamagePipeline();
			UnityRandom instance = new UnityRandom();
			SilkShieldStateService shieldState = new SilkShieldStateService();
			DamageNegotiationService damageNegotiationService = new DamageNegotiationService();
			InputChordRouter inputChordRouter = new InputChordRouter();
			damageNegotiationService.Register(new InvulnerabilityNegotiator("invulnerability", 100, () => leaseService.IsInvulnerable));
			damageNegotiationService.Register(new SilkShieldNegotiator("silk-shield", 50, new SilkShieldPolicy(), () => shieldState.IsActive, () => game.CurrentSilk, () => balance.SilkMother.SilkPerMaskDamage));
			CharmEnhancementRegistry instance2 = new CharmEnhancementRegistry();
			serviceContainer.Register<ManualLogSource>(_log);
			serviceContainer.Register<ConfigFile>(_config);
			serviceContainer.Register<Harmony>(_harmony);
			serviceContainer.Register(balance);
			serviceContainer.Register(damagePipeline);
			serviceContainer.Register((IRandom)instance);
			serviceContainer.Register(leaseService);
			serviceContainer.Register(shieldState);
			serviceContainer.Register(damageNegotiationService);
			serviceContainer.Register(inputChordRouter);
			serviceContainer.Register(instance2);
			serviceContainer.Register((ITemporaryCharmLevelProjection)new InMemoryCharmLevelProjection());
			serviceContainer.Register(gameEventHub);
			serviceContainer.Register((IClock)unityClock);
			serviceContainer.Register(gameBindingConfig);
			serviceContainer.Register(dynamicPatchResolver);
			serviceContainer.Register((IGameApi)game);
			serviceContainer.Register(logUiPresenter);
			serviceContainer.Register(needleforgeAdapter);
			serviceContainer.Register(statusIconLedger);
			serviceContainer.Register(statusIconOptions);
			serviceContainer.Register(statusIconFeature);
			_runtime = new FeatureRuntime(_log, gameEventHub, game, logUiPresenter);
			_runtime.Start();
			_statusLedger = statusIconLedger;
			_statusProjector = statusProjector;
			_statusIcons = statusIconFeature;
			FoundationServices.SetCurrent(_services = new FoundationServices(_log, _config, _harmony, serviceContainer, gameEventHub, unityClock, leaseService, gameBindingConfig, dynamicPatchResolver, game, logUiPresenter, needleforgeAdapter, balance, statusIconLedger, statusIconOptions, statusTextures, statusProjector, statusIconFeature, _runtime, reaperState, beastState, hunterState, dashState, damagePipeline, damageNegotiationService, shieldState, inputChordRouter));
			needleforgeAdapter.Initialize();
			InstallWhiteSlotSystem(needleforgeAdapter);
			_eventPatches = new GameEventPatches(_log, gameEventHub, dynamicPatchResolver, _harmony, damageNegotiationService, game);
			_eventPatches.Install();
			if (StatusIconFeature.ShouldStart(statusIconOptions))
			{
				InstallHudHost(statusIconOptions, statusTextures);
				InstallTickRunner(statusIconFeature);
			}
			if (statusIconOptions.SkillSignalEnabled)
			{
				_skillSignalGo = new GameObject("CrestsEvolveSkillSignal");
				Object.DontDestroyOnLoad((Object)(object)_skillSignalGo);
				_skillSignalGo.AddComponent<SkillUseSignalSource>().Initialize(_log, gameEventHub, statusIconOptions.SkillActionCandidates);
			}
			_log.LogInfo((object)"[CrestsEvolve] foundation ready; satellites attach via FoundationServices.Current.");
		}

		private void InstallTickRunner(StatusIconFeature statusIcons)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_tickRunnerGo = new GameObject("CrestsEvolveStatusIconTick");
			Object.DontDestroyOnLoad((Object)(object)_tickRunnerGo);
			_tickRunner = _tickRunnerGo.AddComponent<StatusIconTickRunner>();
			_tickRunner.Register(statusIcons.Tick);
		}

		private void InstallHudHost(StatusIconOptions statusOptions, StatusIconTextureService statusTextures)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			StatusIconHostConfig obj = new StatusIconHostConfig
			{
				RowAnchorPath = statusOptions.RowAnchor,
				Spacing = statusOptions.Spacing,
				LogHierarchyProbe = statusOptions.LogHierarchyProbe
			};
			if (!StatusIconHostConfig.TryParseOffset(statusOptions.FallbackOffset, out var offset))
			{
				_log.LogWarning((object)("[StatusIcons] invalid FallbackOffset '" + statusOptions.FallbackOffset + "'; using default."));
				((Vector3)(ref offset))..ctor(0f, -2.2f, 0f);
			}
			obj.FallbackOffset = offset;
			HudRootInstaller.Configure(obj, statusTextures, _log);
			_harmony.Patch((MethodBase)AccessTools.Method(typeof(BindOrbHudFrame), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(HudRootInstaller), "Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private void InstallWhiteSlotSystem(NeedleforgeAdapter needleforge)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Expected O, but got Unknown
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Expected O, but got Unknown
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Expected O, but got Unknown
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Expected O, but got Unknown
			//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Expected O, but got Unknown
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Expected O, but got Unknown
			//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Expected O, but got Unknown
			//IL_055b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0569: Expected O, but got Unknown
			//IL_05f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ff: Expected O, but got Unknown
			//IL_0648: Unknown result type (might be due to invalid IL or missing references)
			//IL_0655: Expected O, but got Unknown
			if (WhiteToolSystem.TryInstall(needleforge, _log))
			{
				WhiteToolSystem.RegisterAllWhiteTools(_log);
				WhiteSlotInstaller.Configure(_log);
				WhiteSlotInstaller.WhiteType = WhiteToolSystem.WhiteType;
				WhiteSlotInstaller.Enabled = true;
				_harmony.Patch((MethodBase)AccessTools.Method(typeof(ToolItemManager), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(WhiteSlotInstaller), "Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				WhiteSlotToolFilterPatch.Configure(_log);
				WhiteSlotToolFilterPatch.WhiteType = WhiteToolSystem.WhiteType;
				WhiteUniversalSlotSync.Configure(_log);
				WhiteUniversalSlotSync.WhiteType = WhiteToolSystem.WhiteType;
				_slotTypeGetter = AccessTools.PropertyGetter(typeof(InventoryToolCrestSlot), "Type");
				if (_slotTypeGetter != null)
				{
					_harmony.Patch(_slotTypeGetter, (HarmonyMethod)null, new HarmonyMethod(typeof(WhiteSlotToolFilterPatch), "TypePostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					_log.LogWarning((object)"[WhiteSlotFilter] InventoryToolCrestSlot.Type getter not found; white-slot blue/yellow filter disabled.");
				}
				_crestHasSlotMethod = AccessTools.Method(typeof(InventoryItemToolManager), "CrestHasSlot", (Type[])null, (Type[])null);
				if (_crestHasSlotMethod != null)
				{
					_harmony.Patch(_crestHasSlotMethod, (HarmonyMethod)null, new HarmonyMethod(typeof(WhiteSlotToolFilterPatch), "CrestHasSlotPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					_log.LogWarning((object)"[WhiteSlotFilter] InventoryItemToolManager.CrestHasSlot not found; tool-list hint disabled.");
				}
				_startSelectionMethod = AccessTools.Method(typeof(InventoryItemToolManager), "StartSelection", new Type[1] { typeof(InventoryToolCrestSlot) }, (Type[])null);
				if (_startSelectionMethod != null)
				{
					_harmony.Patch(_startSelectionMethod, new HarmonyMethod(typeof(WhiteSlotToolFilterPatch), "StartSelectionPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					_log.LogWarning((object)"[WhiteSlotFilter] InventoryItemToolManager.StartSelection not found; white-slot tool selection disabled.");
				}
				_endSelectionMethod = AccessTools.Method(typeof(InventoryItemToolManager), "EndSelection", new Type[1] { typeof(InventoryItemTool) }, (Type[])null);
				if (_endSelectionMethod != null)
				{
					_harmony.Patch(_endSelectionMethod, new HarmonyMethod(typeof(WhiteSlotToolFilterPatch), "EndSelectionPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					_log.LogWarning((object)"[WhiteSlotFilter] InventoryItemToolManager.EndSelection not found; white-slot tool confirm disabled.");
				}
				_slotSetEquippedMethod = AccessTools.Method(typeof(InventoryToolCrestSlot), "SetEquipped", new Type[3]
				{
					typeof(ToolItem),
					typeof(bool),
					typeof(bool)
				}, (Type[])null);
				if (_slotSetEquippedMethod != null)
				{
					_harmony.Patch(_slotSetEquippedMethod, (HarmonyMethod)null, new HarmonyMethod(typeof(WhiteSlotToolFilterPatch), "SetEquippedPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					_log.LogWarning((object)"[WhiteSlotFilter] InventoryToolCrestSlot.SetEquipped not found; white-slot cache refresh disabled.");
				}
				_placeToolMethod = AccessTools.Method(typeof(InventoryItemToolManager), "PlaceTool", new Type[2]
				{
					typeof(InventoryToolCrestSlot),
					typeof(bool)
				}, (Type[])null);
				if (_placeToolMethod != null)
				{
					HarmonyMethod val = new HarmonyMethod(typeof(WhiteSlotToolFilterPatch), "PlaceToolPrefix", (Type[])null)
					{
						priority = 800
					};
					_harmony.Patch(_placeToolMethod, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					_log.LogWarning((object)"[WhiteSlotFilter] InventoryItemToolManager.PlaceTool not found; white-tool slot restriction disabled.");
				}
				_isSlotInvalidMethod = AccessTools.Method(typeof(InventoryToolCrestSlot), "IsSlotInvalid", new Type[2]
				{
					typeof(ToolItemType),
					typeof(InventoryToolCrestSlot)
				}, (Type[])null);
				if (_isSlotInvalidMethod != null)
				{
					_harmony.Patch(_isSlotInvalidMethod, (HarmonyMethod)null, new HarmonyMethod(typeof(WhiteSlotToolFilterPatch), "IsSlotInvalidPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					_log.LogWarning((object)"[WhiteSlotFilter] InventoryToolCrestSlot.IsSlotInvalid not found; white-slot navigation disabled.");
				}
				_refreshToolsMethod = AccessTools.Method(typeof(InventoryItemToolManager), "RefreshTools", new Type[2]
				{
					typeof(bool),
					typeof(bool)
				}, (Type[])null);
				if (_refreshToolsMethod != null)
				{
					_harmony.Patch(_refreshToolsMethod, (HarmonyMethod)null, new HarmonyMethod(typeof(WhiteSlotToolFilterPatch), "RefreshToolsPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					_log.LogWarning((object)"[WhiteSlotFilter] InventoryItemToolManager.RefreshTools(bool,bool) not found; white-slot list highlighting disabled.");
				}
				_toolUpdateEquippedDisplayMethod = AccessTools.Method(typeof(InventoryItemTool), "UpdateEquippedDisplay", new Type[1] { typeof(bool) }, (Type[])null);
				if (_toolUpdateEquippedDisplayMethod != null)
				{
					_harmony.Patch(_toolUpdateEquippedDisplayMethod, (HarmonyMethod)null, new HarmonyMethod(typeof(WhiteSlotToolFilterPatch), "UpdateEquippedDisplayPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					_log.LogWarning((object)"[WhiteSlotFilter] InventoryItemTool.UpdateEquippedDisplay(bool) not found; white-slot tool highlighting disabled.");
				}
				_setEquippedCrestMethod = AccessTools.Method(typeof(ToolItemManager), "SetEquippedCrest", new Type[1] { typeof(string) }, (Type[])null);
				if (_setEquippedCrestMethod != null)
				{
					_harmony.Patch(_setEquippedCrestMethod, new HarmonyMethod(typeof(WhiteUniversalSlotSync), "Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					_log.LogWarning((object)"[WhiteUniversalSlot] SetEquippedCrest(string) not found; white-slot sync disabled.");
				}
				WhiteToolTextPatch.Configure();
				ToolDescriptionPatch.Configure(_log);
				_languageGetMethod = AccessTools.Method(typeof(Language), "Get", new Type[2]
				{
					typeof(string),
					typeof(string)
				}, (Type[])null);
				if (_languageGetMethod != null)
				{
					_harmony.Patch(_languageGetMethod, new HarmonyMethod(typeof(WhiteToolTextPatch), "Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					_log.LogWarning((object)"[IoniaDescription] Language.Get(string,string) not found; description fallback disabled.");
				}
				MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(InventoryItemTool), "Description");
				if (methodInfo != null)
				{
					_harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(ToolDescriptionPatch), "Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					_log.LogWarning((object)"[ToolDescription] InventoryItemTool.Description not found; tool description suffix disabled.");
				}
			}
		}

		public void Dispose()
		{
			ToolDescriptionRegistry.Clear();
			_eventPatches?.Dispose();
			if ((Object)(object)_skillSignalGo != (Object)null)
			{
				Object.Destroy((Object)(object)_skillSignalGo);
			}
			if ((Object)(object)_tickRunnerGo != (Object)null)
			{
				Object.Destroy((Object)(object)_tickRunnerGo);
			}
			_statusIcons?.Dispose();
			_runtime?.Dispose();
			ToolEquipsDiagnostics.Enabled = false;
			_harmony.UnpatchSelf();
			FoundationServices.SetCurrent(null);
			_services = null;
		}
	}
}