using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using NazhikaCore.Bosses;
using NazhikaCore.Features.Classes;
using NazhikaCore.Features.DeathMessages;
using NazhikaCore.Patches;
using NazhikaCore.RPC;
using NazhikaCore.StatusEffects;
using NazhikaCore.UI;
using NazhikaCore.Utils;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("NazhikaCore")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("NazhikaCore")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("11D23B88-B6B8-482B-9F58-4694D6AD10FC")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.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;
		}
	}
}
namespace NazhikaCore
{
	[BepInPlugin("com.dreams.nazhikacore", "Nazhika Core", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class MainPlugin : BaseUnityPlugin
	{
		private Harmony _harmony;

		internal static ConfigEntry<KeyboardShortcut> ClassSkillKey;

		public static string ModPath { get; private set; }

		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			_harmony = new Harmony("com.dreams.nazhikacore");
			Log.Init(((BaseUnityPlugin)this).Logger);
			ModPath = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			((BaseUnityPlugin)this).Logger.LogInfo((object)("[NazhikaCore] ModPath = " + ModPath));
			ClassSkillKey = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Keybinds", "ClassSkillKey", new KeyboardShortcut((KeyCode)57, Array.Empty<KeyCode>()), "Tecla para activar la habilidad de clase.");
			SkillsUI.Init(_harmony);
			AdrenalinePatch.Init(_harmony);
			LoginClasses.Init(_harmony);
			OrbsUI.Init(_harmony);
			TankAi.Init(_harmony);
			FistBjornClawRecipePatch.Init(_harmony);
			SE_BleedingSetup.Init();
			SE_FatigueSetup.Init();
			SE_CurseSetup.Init();
			SE_BlindnessSetup.Init();
			SE_OrbGaugeSetup.Init();
			SE_ParryRegenSetup.Init();
			SE_PassiveAtkSpeedSetup.Init();
			SE_WarcrySetup.Init();
			SE_TankPassiveSetup.Init();
			SE_SwordLightningSetup.Init();
			SE_SwordPoisonSetup.Init();
			SE_SwordWitherSetup.Init();
			SE_SpearStacksSetup.Init();
			SE_BloodBurstSetup.Init();
			SE_BerserkfurySetup.Init();
			SE_BerserkBurstSetup.Init();
			SE_BerserkerGodSetup.Init();
			SE_BerserkerGodCooldownSetup.Init();
			SE_FocusShotSetup.Init();
			SE_LightningStormSetup.Init();
			SE_MagicRootsSetup.Init();
			SE_ToxicCloudSetup.Init();
			SE_LavaRocksSetup.Init();
			BerserkerPatches.Init(_harmony);
			BalanceConfig.Init(((BaseUnityPlugin)this).Config);
			ClassSkillsPatches.Init(_harmony);
			LightningStorm_BlockAttackPatch.Init(_harmony);
			Monk_KiPatches.Init(_harmony);
			FatiguePatch.Init(_harmony);
			ArcherCritPatches.Init(_harmony);
			SwordLightningRPC.Init(_harmony);
			SwordPoisonRPC.Init(_harmony);
			SwordWitherRPC.Init(_harmony);
			WarcryRPC.Init(_harmony);
			BerserkBurstRPC.Init(_harmony);
			MonkLeapSkill.Init(_harmony);
			MonkChiReleaseSkill.Init(_harmony);
			MonkLeapPatches.Init(_harmony);
			BleedingPopupRPC.Init(_harmony);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[NazhikaCore] ANTES de BloodBurstNet.Init");
			BloodBurstNet.Init(_harmony);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[NazhikaCore] DESPUES de BloodBurstNet.Init");
			ClearStatusEffectsRPC.Init(_harmony);
			Player_CheerEmoteRPC.Init(_harmony);
			Player_ToxicCloudRPC.Init(_harmony);
			EikthyrBoss.Init(_harmony, ((BaseUnityPlugin)this).Config, ((BaseUnityPlugin)this).Logger);
			SelectorClass.Init();
			ClearEffects.Init();
			ShoutDeath.Init(((BaseUnityPlugin)this).Config, _harmony, ((BaseUnityPlugin)this).Logger);
			ClassSpriteLoader.ImageFolder = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "Images");
			GUIManager.OnCustomGUIAvailable += ClassSelectionUI.Instance.OnGUIAvailable;
			PrefabManager.OnVanillaPrefabsAvailable += delegate
			{
				GameObject prefab = PrefabManager.Instance.GetPrefab("Custom_Magetable_Ext_1");
				if ((Object)(object)prefab != (Object)null && (Object)(object)prefab.GetComponent<MageTableInteract>() == (Object)null)
				{
					prefab.AddComponent<MageTableInteract>();
				}
			};
			((BaseUnityPlugin)this).Logger.LogInfo((object)"✅ NazhikaCore inicializado correctamente.");
		}

		private void Update()
		{
			ClassManager.Update();
			MonkLeapSkill.EnsureRpcRegistered();
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"\ud83d\uded1 NazhikaCore descargado y parches removidos.");
		}
	}
}
namespace NazhikaCore.Utils
{
	public static class EmotesNet
	{
		public static void PlayCheer(Player player)
		{
			if (!((Object)(object)((Character)(player?)).m_nview == (Object)null) && ((Character)player).m_nview.IsValid())
			{
				((Character)player).m_nview.InvokeRPC(ZNetView.Everybody, "RPC_Nazhika_PlayCheer", Array.Empty<object>());
			}
		}
	}
	public static class IconHelper
	{
		public static Sprite Load(string fileName)
		{
			string text = Path.Combine(MainPlugin.ModPath, "NazhikaCore", "Assets", "Icons");
			string text2 = Path.Combine(text, fileName);
			Debug.Log((object)("[NazhikaCore.IconHelper] Buscando ícono en: " + text));
			if (!File.Exists(text2))
			{
				return null;
			}
			Sprite val = AssetUtils.LoadSpriteFromFile(text2);
			if ((Object)(object)val != (Object)null)
			{
				Debug.Log((object)("[NazhikaCore.IconHelper] ✅ Ícono cargado: " + fileName));
			}
			else
			{
				Debug.LogWarning((object)("[NazhikaCore.IconHelper] ⚠\ufe0f Error al cargar sprite desde: " + text2));
			}
			return val;
		}
	}
	public static class Log
	{
		private static ManualLogSource _logger;

		public static void Init(ManualLogSource logger)
		{
			_logger = logger;
		}

		public static void Info(string message)
		{
			_logger.LogInfo((object)message);
		}

		public static void Warning(string message)
		{
			_logger.LogWarning((object)message);
		}

		public static void Error(string message)
		{
			_logger.LogError((object)message);
		}
	}
}
namespace NazhikaCore.StatusEffects
{
	public class SE_BerserkBurst : StatusEffect
	{
		[CompilerGenerated]
		private sealed class <GetCandidateItems>d__22 : IEnumerable<ItemData>, IEnumerable, IEnumerator<ItemData>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private ItemData <>2__current;

			private int <>l__initialThreadId;

			private Player p;

			public Player <>3__p;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = ((Humanoid)p).GetCurrentWeapon();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = ((Humanoid)p).GetRightItem();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = ((Humanoid)p).GetLeftItem();
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					return false;
				}
			}

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

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

			[DebuggerHidden]
			IEnumerator<ItemData> IEnumerable<ItemData>.GetEnumerator()
			{
				<GetCandidateItems>d__22 <GetCandidateItems>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetCandidateItems>d__ = this;
				}
				else
				{
					<GetCandidateItems>d__ = new <GetCandidateItems>d__22(0);
				}
				<GetCandidateItems>d__.p = <>3__p;
				return <GetCandidateItems>d__;
			}

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

		public static readonly int NameHash = StringExtensionMethods.GetStableHashCode("SE_BerserkBurst");

		public static float BurstDuration = 20f;

		private Character m_char;

		private const string FuryKey = "naz_fury";

		private const string BurstCooldownUntilKey = "naz_berserkburst_cd_until";

		private bool _fxApplied;

		private bool _fxTried;

		private float _waitTimeout = 3f;

		private readonly List<GameObject> _spawnedRight = new List<GameObject>();

		private readonly List<GameObject> _spawnedLeft = new List<GameObject>();

		private const string RightHandPath = "Visual/Armature/Hips/Spine/Spine1/Spine2/RightShoulder/RightArm/RightForeArm/RightHand/RightHand_Attach/attach(Clone)";

		private const string LeftHandPath = "Visual/Armature/Hips/Spine/Spine1/Spine2/LeftShoulder/LeftArm/LeftForeArm/LeftHand/LeftHand_Attach/attach(Clone)";

		public static float DamageMult => BalanceConfig.BerserkDamageMult;

		public SE_BerserkBurst()
		{
			((Object)this).name = "SE_BerserkBurst";
			base.m_name = "Berserker Burst";
			base.m_icon = IconHelper.Load("BerserkerBurst.png");
			base.m_tooltip = $"Aumento de daño temporal (x{DamageMult:0.00}).";
			base.m_ttl = BurstDuration;
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
			m_char = character;
			_fxApplied = false;
			_fxTried = false;
			_waitTimeout = 3f;
			_spawnedRight.Clear();
			_spawnedLeft.Clear();
			Player val = (Player)(object)((character is Player) ? character : null);
			if (val != null && (Object)(object)((Character)val).m_nview != (Object)null && ((Character)val).m_nview.IsValid())
			{
				ZDO zDO = ((Character)val).m_nview.GetZDO();
				if (zDO != null)
				{
					zDO.Set("naz_fury", 0f);
				}
			}
			Player val2 = (Player)(object)((character is Player) ? character : null);
			if (val2 != null)
			{
				BerserkBurstRPC.ApplyFromStatus(val2, active: true);
				BerserkBurstRPC.BroadcastActivated(val2);
			}
		}

		public override void UpdateStatusEffect(float dt)
		{
			((StatusEffect)this).UpdateStatusEffect(dt);
			Character @char = m_char;
			Player val = (Player)(object)((@char is Player) ? @char : null);
			if ((Object)(object)val != (Object)null && (Object)(object)((Character)val).m_nview != (Object)null && ((Character)val).m_nview.IsValid())
			{
				ZDO zDO = ((Character)val).m_nview.GetZDO();
				if (zDO != null && zDO.GetFloat("naz_fury", 0f) > 0f)
				{
					zDO.Set("naz_fury", 0f);
				}
			}
			Character char2 = m_char;
			Player val2 = (Player)(object)((char2 is Player) ? char2 : null);
			if ((Object)(object)val2 == (Object)null || (Object)(object)Player.m_localPlayer != (Object)(object)val2 || _fxApplied || (_fxTried && _waitTimeout <= 0f))
			{
				return;
			}
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				_waitTimeout -= dt;
			}
			else if (!TryApplyAxeFX(val2))
			{
				_waitTimeout -= dt;
				if (_waitTimeout <= 0f)
				{
					_fxTried = true;
				}
			}
		}

		public override void Stop()
		{
			((StatusEffect)this).Stop();
			Character @char = m_char;
			Player val = (Player)(object)((@char is Player) ? @char : null);
			if ((Object)(object)val != (Object)null)
			{
				BerserkBurstRPC.ApplyFromStatus(val, active: false);
			}
			CleanupAxeFX();
			if ((Object)(object)val != (Object)null && (Object)(object)((Character)val).m_nview != (Object)null && ((Character)val).m_nview.IsValid() && ((Character)val).m_nview.GetZDO() != null && (Object)(object)ZNet.instance != (Object)null)
			{
				ZDO zDO = ((Character)val).m_nview.GetZDO();
				zDO.Set("naz_fury", 0f);
				float num = (float)ZNet.instance.GetTimeSeconds();
				zDO.Set("naz_berserkburst_cd_until", num + 20f);
			}
			if ((Object)(object)val != (Object)null && !((Character)val).IsDead())
			{
				SEMan sEMan = ((Character)val).GetSEMan();
				if (sEMan != null && (Object)(object)sEMan.GetStatusEffect(SE_Berserkfury.NameHash) == (Object)null)
				{
					sEMan.AddStatusEffect(SE_Berserkfury.NameHash, false, 0, 0f);
				}
				if ((Object)(object)Player.m_localPlayer == (Object)(object)val)
				{
					SkillsUI.StartCooldown(20f);
				}
			}
		}

		private bool TryApplyAxeFX(Player player)
		{
			//IL_016b: 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_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			string itemName;
			bool flag = TryFindOneHandedAxe(player, out itemName);
			string itemName2;
			bool flag2 = !flag && TryFindTwoHandedAxe(player, out itemName2);
			if (!flag && !flag2)
			{
				_fxTried = true;
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "nihoggrAxe", "Viking_Axe", "collider" };
			string text;
			bool flag3;
			bool flag4;
			if (flag)
			{
				text = "teq_nihoggr_axe";
				flag3 = true;
				flag4 = true;
			}
			else
			{
				text = "teq_skoll_battleaxe";
				flag3 = true;
				flag4 = false;
				hashSet.Add("LeviathanAxe");
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(text);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				return false;
			}
			Transform val = itemPrefab.transform.Find("attach");
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Transform val2 = (flag3 ? ((Component)player).transform.Find("Visual/Armature/Hips/Spine/Spine1/Spine2/RightShoulder/RightArm/RightForeArm/RightHand/RightHand_Attach/attach(Clone)") : null);
			Transform val3 = (flag4 ? ((Component)player).transform.Find("Visual/Armature/Hips/Spine/Spine1/Spine2/LeftShoulder/LeftArm/LeftForeArm/LeftHand/LeftHand_Attach/attach(Clone)") : null);
			if (flag3 && (Object)(object)val2 == (Object)null)
			{
				return false;
			}
			if (flag4 && (Object)(object)val3 == (Object)null)
			{
				return false;
			}
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < val.childCount; i++)
			{
				Transform child = val.GetChild(i);
				if (!hashSet.Contains(((Object)child).name))
				{
					if ((Object)(object)val2 != (Object)null)
					{
						GameObject val4 = Object.Instantiate<GameObject>(((Component)child).gameObject, val2);
						((Object)val4).name = ((Object)child).name;
						val4.transform.localPosition = child.localPosition;
						val4.transform.localRotation = child.localRotation;
						val4.transform.localScale = child.localScale;
						ForceActivateHierarchy(val4);
						_spawnedRight.Add(val4);
						num++;
					}
					if ((Object)(object)val3 != (Object)null)
					{
						GameObject val5 = Object.Instantiate<GameObject>(((Component)child).gameObject, val3);
						((Object)val5).name = ((Object)child).name;
						val5.transform.localPosition = child.localPosition;
						val5.transform.localRotation = child.localRotation;
						val5.transform.localScale = child.localScale;
						ForceActivateHierarchy(val5);
						_spawnedLeft.Add(val5);
						num2++;
					}
				}
			}
			_fxApplied = num + num2 > 0;
			_fxTried = true;
			return _fxApplied;
		}

		private void CleanupAxeFX()
		{
			_fxApplied = false;
			SafeCleanup(_spawnedRight);
			SafeCleanup(_spawnedLeft);
			_spawnedRight.Clear();
			_spawnedLeft.Clear();
		}

		private static bool TryFindOneHandedAxe(Player p, out string itemName)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			itemName = null;
			foreach (ItemData candidateItem in GetCandidateItems(p))
			{
				if (candidateItem?.m_shared != null && (int)candidateItem.m_shared.m_skillType == 7 && (int)candidateItem.m_shared.m_itemType == 3)
				{
					itemName = candidateItem.m_shared.m_name;
					return true;
				}
			}
			return false;
		}

		private static bool TryFindTwoHandedAxe(Player p, out string itemName)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			itemName = null;
			foreach (ItemData candidateItem in GetCandidateItems(p))
			{
				if (candidateItem?.m_shared != null && (int)candidateItem.m_shared.m_skillType == 7 && (int)candidateItem.m_shared.m_itemType == 14)
				{
					itemName = candidateItem.m_shared.m_name;
					return true;
				}
			}
			return false;
		}

		[IteratorStateMachine(typeof(<GetCandidateItems>d__22))]
		private static IEnumerable<ItemData> GetCandidateItems(Player p)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetCandidateItems>d__22(-2)
			{
				<>3__p = p
			};
		}

		private static void ForceActivateHierarchy(GameObject root)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)root == (Object)null))
			{
				SetActiveRecursive(root.transform, active: true);
				ParticleSystem[] componentsInChildren = root.GetComponentsInChildren<ParticleSystem>(true);
				foreach (ParticleSystem val in componentsInChildren)
				{
					EmissionModule emission = val.emission;
					((EmissionModule)(ref emission)).enabled = true;
					val.Clear(true);
					val.Play(true);
				}
				TrailRenderer[] componentsInChildren2 = root.GetComponentsInChildren<TrailRenderer>(true);
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					((Renderer)componentsInChildren2[j]).enabled = true;
					componentsInChildren2[j].Clear();
				}
				LineRenderer[] componentsInChildren3 = root.GetComponentsInChildren<LineRenderer>(true);
				for (int k = 0; k < componentsInChildren3.Length; k++)
				{
					((Renderer)componentsInChildren3[k]).enabled = true;
				}
				Light[] componentsInChildren4 = root.GetComponentsInChildren<Light>(true);
				for (int l = 0; l < componentsInChildren4.Length; l++)
				{
					((Behaviour)componentsInChildren4[l]).enabled = true;
				}
			}
		}

		private static void SetActiveRecursive(Transform t, bool active)
		{
			((Component)t).gameObject.SetActive(active);
			for (int i = 0; i < t.childCount; i++)
			{
				SetActiveRecursive(t.GetChild(i), active);
			}
		}

		private static int SafeCleanup(List<GameObject> list)
		{
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				if ((Object)(object)list[i] != (Object)null)
				{
					Object.Destroy((Object)(object)list[i]);
					num++;
				}
			}
			list.Clear();
			return num;
		}
	}
	public static class SE_BerserkBurstSetup
	{
		private static bool _asmRegistered;

		public static void Init()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			SE_BerserkBurst sE_BerserkBurst = ScriptableObject.CreateInstance<SE_BerserkBurst>();
			CustomStatusEffect val = new CustomStatusEffect((StatusEffect)(object)sE_BerserkBurst, true);
			ItemManager.Instance.AddStatusEffect(val);
			Log.Info("[NazhikaCore] ✅ SE_BerserkBurst registrado (usa BerserkBurstRPC para FX+SFX+Roar).");
			if (_asmRegistered)
			{
				return;
			}
			_asmRegistered = true;
			AnimationSpeedManager.Add(delegate(Character character, double speed)
			{
				Player val2 = (Player)(object)((character is Player) ? character : null);
				if ((Object)(object)val2 == (Object)null)
				{
					return speed;
				}
				if (!ClassApi.HasClass(val2, "Berserker"))
				{
					return speed;
				}
				if (!((Character)val2).InAttack() || ((Humanoid)val2).m_currentAttack == null)
				{
					return speed;
				}
				SEMan sEMan = ((Character)val2).GetSEMan();
				return (sEMan == null || (Object)(object)sEMan.GetStatusEffect(SE_BerserkBurst.NameHash) == (Object)null) ? speed : (speed * (double)BalanceConfig.BerserkAtkSpeedMult);
			});
		}
	}
	public class SE_BerserkerGod : StatusEffect
	{
		public static readonly int NameHash = StringExtensionMethods.GetStableHashCode("SE_BerserkerGod");

		public const string FuryBlockZdoKey = "naz_fury_block";

		public const string GodCdZdoKey = "naz_bg_cd_until";

		private const float CooldownSeconds = 60f;

		public SE_BerserkerGod()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			((Object)this).name = "SE_BerserkerGod";
			base.m_name = "Berserker God";
			base.m_icon = IconHelper.Load("BerserkerGod.png");
			base.m_tooltip = "Invulnerable por 8s";
			base.m_ttl = 8f;
			base.m_cooldown = 60f;
			base.m_startMessage = "† Berserker God activado †";
			base.m_startMessageType = (MessageType)2;
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
			try
			{
				ZDO val = (((Object)(object)base.m_character != (Object)null && (Object)(object)base.m_character.m_nview != (Object)null) ? base.m_character.m_nview.GetZDO() : null);
				if (val != null)
				{
					val.Set("naz_fury_block", true);
				}
			}
			catch
			{
			}
		}

		public override void Stop()
		{
			try
			{
				ZDO val = (((Object)(object)base.m_character != (Object)null && (Object)(object)base.m_character.m_nview != (Object)null) ? base.m_character.m_nview.GetZDO() : null);
				if (val != null)
				{
					val.Set("naz_fury_block", false);
				}
				Character character = base.m_character;
				SEMan val2 = ((character != null) ? character.GetSEMan() : null);
				if (val2 != null && (Object)(object)val2.GetStatusEffect(SE_BerserkerGodCooldown.NameHash) == (Object)null)
				{
					SE_BerserkerGodCooldown sE_BerserkerGodCooldown = val2.AddStatusEffect(SE_BerserkerGodCooldown.NameHash, false, 0, 0f) as SE_BerserkerGodCooldown;
					if ((Object)(object)sE_BerserkerGodCooldown != (Object)null)
					{
						sE_BerserkerGodCooldown.SetDuration(60f);
					}
				}
				float num = (((Object)(object)EnvMan.instance != (Object)null) ? ((float)EnvMan.instance.m_totalSeconds) : Time.time);
				if (val != null)
				{
					val.Set("naz_bg_cd_until", num + 60f);
				}
			}
			catch
			{
			}
			((StatusEffect)this).Stop();
		}
	}
	public static class SE_BerserkerGodSetup
	{
		public static void Init()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			SE_BerserkerGod sE_BerserkerGod = ScriptableObject.CreateInstance<SE_BerserkerGod>();
			CustomStatusEffect val = new CustomStatusEffect((StatusEffect)(object)sE_BerserkerGod, true);
			ItemManager.Instance.AddStatusEffect(val);
			Debug.Log((object)"[NazhikaCore] ✅ SE_BerserkerGod registrado.");
		}
	}
	public class SE_BerserkerGodCooldown : StatusEffect
	{
		public const string InternalName = "SE_BerserkerGodCooldown";

		public static readonly int NameHash = StringExtensionMethods.GetStableHashCode("SE_BerserkerGodCooldown");

		public SE_BerserkerGodCooldown()
		{
			((Object)this).name = "SE_BerserkerGodCooldown";
			base.m_name = "God";
			base.m_tooltip = "En recarga...";
			base.m_ttl = 60f;
			base.m_cooldownIcon = true;
			base.m_icon = IconHelper.Load("BerserkerGod.png");
		}

		public void SetDuration(float seconds)
		{
			base.m_ttl = Mathf.Max(0.1f, seconds);
		}

		public override void UpdateStatusEffect(float dt)
		{
			((StatusEffect)this).UpdateStatusEffect(dt);
			float num = Mathf.Max(0f, base.m_ttl - base.m_time);
			base.m_tooltip = $"En recarga ({num:0}s)";
		}
	}
	public static class SE_BerserkerGodCooldownSetup
	{
		public static void Init()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			SE_BerserkerGodCooldown sE_BerserkerGodCooldown = ScriptableObject.CreateInstance<SE_BerserkerGodCooldown>();
			CustomStatusEffect val = new CustomStatusEffect((StatusEffect)(object)sE_BerserkerGodCooldown, true);
			ItemManager.Instance.AddStatusEffect(val);
			Debug.Log((object)"[NazhikaCore] ✅ SE_BerserkerGodCooldown registrado.");
		}
	}
	public class SE_Berserkfury : StatusEffect
	{
		public static readonly int NameHash = StringExtensionMethods.GetStableHashCode("SE_Berserkfury");

		private const string FuryKey = "naz_fury";

		public SE_Berserkfury()
		{
			((Object)this).name = "SE_Berserkfury";
			base.m_name = "Berserker Fury";
			base.m_icon = IconHelper.Load("BerserkerFury.png");
			base.m_tooltip = "La furia se carga al golpear.";
			base.m_ttl = 999999f;
		}

		public override string GetIconText()
		{
			Character character = base.m_character;
			object obj;
			if (character == null)
			{
				obj = null;
			}
			else
			{
				ZNetView nview = character.m_nview;
				obj = ((nview != null) ? nview.GetZDO() : null);
			}
			ZDO val = (ZDO)obj;
			if (val == null)
			{
				return "";
			}
			float @float = val.GetFloat("naz_fury", 0f);
			if (!(@float > 0f))
			{
				return "";
			}
			return ((int)@float).ToString();
		}
	}
	public static class SE_BerserkfurySetup
	{
		public static void Init()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			SE_Berserkfury sE_Berserkfury = ScriptableObject.CreateInstance<SE_Berserkfury>();
			CustomStatusEffect val = new CustomStatusEffect((StatusEffect)(object)sE_Berserkfury, true);
			ItemManager.Instance.AddStatusEffect(val);
			Log.Info("[NazhikaCore] ✅ SE_Berserkfury registrado (marcador).");
		}
	}
	public class SE_Bleeding : StatusEffect
	{
		public static readonly int NameHash = StringExtensionMethods.GetStableHashCode("SE_Bleeding");

		private float tickTimer;

		private float fxTimer;

		private const float BaseHpCap = 10000f;

		private const float MoveSpeedMultiplier = 0.95f;

		internal const string ZdoBleedStacksKey = "nz_bleed_stacks";

		private int _stacks = 1;

		public int Stacks => _stacks;

		public SE_Bleeding()
		{
			((Object)this).name = "SE_Bleeding";
			base.m_name = "Bleeding";
			base.m_tooltip = "Estás sangrando: pierdes vida cada segundo.";
			base.m_icon = IconHelper.Load("bleed.png");
			base.m_ttl = 5f;
		}

		public override void Setup(Character c)
		{
			((StatusEffect)this).Setup(c);
			if (_stacks <= 0)
			{
				_stacks = 1;
			}
			_stacks = Mathf.Clamp(_stacks, 1, BalanceConfig.BleedMaxStacks);
			tickTimer = 0f;
			fxTimer = 0f;
			WriteStacksToZdo(_stacks);
			ApplyBleedTick();
		}

		public override void ModifySpeed(float baseSpeed, ref float speed, Character character, Vector3 dir)
		{
			speed *= 0.95f;
		}

		public override void UpdateStatusEffect(float dt)
		{
			((StatusEffect)this).UpdateStatusEffect(dt);
			tickTimer += dt;
			fxTimer += dt;
			if (tickTimer >= BalanceConfig.BleedTickInterval)
			{
				tickTimer = 0f;
				ApplyBleedTick();
			}
			if (fxTimer >= 1f)
			{
				fxTimer = 0f;
				SpawnBloodFXSafe();
			}
			base.m_tooltip = $"Estás sangrando ({_stacks} stack(s)): el daño por tick se duplica a {BalanceConfig.BleedMaxStacks} stacks. " + "Movimiento -5% (no afecta ataque).";
		}

		public void AddBleedStack()
		{
			_stacks = Mathf.Clamp(_stacks + 1, 1, BalanceConfig.BleedMaxStacks);
			base.m_time = 0f;
			if (base.m_ttl < 4f)
			{
				base.m_ttl = 4f;
			}
			WriteStacksToZdo(_stacks);
		}

		private void ApplyBleedTick()
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)base.m_character == (Object)null || !base.m_character.IsOwner())
			{
				return;
			}
			float maxHealthSafe = GetMaxHealthSafe(base.m_character);
			if (!(maxHealthSafe <= 0f))
			{
				int tier = GetTier(maxHealthSafe);
				float num = maxHealthSafe * 0.1f;
				if (tier >= 7 && num > 10000f)
				{
					num = 10000f;
				}
				float fixedBaseByTier = GetFixedBaseByTier(tier);
				float num2 = num * BalanceConfig.BleedFractionPerStack;
				float num3 = fixedBaseByTier + num2;
				float stackMultiplier = GetStackMultiplier(_stacks);
				float num4 = Mathf.Max(0f, num3 * stackMultiplier);
				float health = base.m_character.GetHealth();
				float health2 = Mathf.Max(0f, health - num4);
				base.m_character.SetHealth(health2);
				BleedingPopupRPC.SendBleedPopup(base.m_character.GetCenterPoint(), num4, _stacks);
				Debug.Log((object)($"[NazhikaCore/Bleeding] {((Object)base.m_character).name} maxHP={maxHealthSafe:0} tier={tier} stacks={_stacks} " + $"hpBase={num:0.#} fixed={fixedBaseByTier:0.#} scaled1={num2:0.##} base1={num3:0.##} mult={stackMultiplier:0.###} dmg={num4:0.##}"));
			}
		}

		private float GetStackMultiplier(int stacks)
		{
			int bleedMaxStacks = BalanceConfig.BleedMaxStacks;
			stacks = Mathf.Clamp(stacks, 1, bleedMaxStacks);
			if (bleedMaxStacks <= 1)
			{
				return 1f;
			}
			return 1f + ((float)stacks - 1f) / ((float)bleedMaxStacks - 1f);
		}

		private static int GetTier(float hp)
		{
			if (hp < 60f)
			{
				return 0;
			}
			if (hp < 180f)
			{
				return 1;
			}
			if (hp < 450f)
			{
				return 2;
			}
			if (hp < 1500f)
			{
				return 3;
			}
			if (hp < 3000f)
			{
				return 4;
			}
			if (hp < 5000f)
			{
				return 5;
			}
			if (hp < 10000f)
			{
				return 6;
			}
			if (hp < 50000f)
			{
				return 7;
			}
			return 8;
		}

		private static float GetFixedBaseByTier(int tier)
		{
			return tier switch
			{
				0 => BalanceConfig.BleedFixedT0, 
				1 => BalanceConfig.BleedFixedT1, 
				2 => BalanceConfig.BleedFixedT2, 
				3 => BalanceConfig.BleedFixedT3, 
				4 => BalanceConfig.BleedFixedT4, 
				5 => BalanceConfig.BleedFixedT5, 
				6 => BalanceConfig.BleedFixedT6, 
				7 => BalanceConfig.BleedFixedT7, 
				8 => BalanceConfig.BleedFixedT8, 
				_ => 10f, 
			};
		}

		private static float GetMaxHealthSafe(Character ch)
		{
			try
			{
				return ch.GetMaxHealth();
			}
			catch
			{
				return Mathf.Max(1f, ch.GetHealth());
			}
		}

		private void SpawnBloodFXSafe()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)base.m_character == (Object)null) && !((Object)(object)ZNetScene.instance == (Object)null))
			{
				GameObject prefab = ZNetScene.instance.GetPrefab("vfx_BloodHit");
				if (Object.op_Implicit((Object)(object)prefab))
				{
					Object.Instantiate<GameObject>(prefab, base.m_character.GetCenterPoint(), Quaternion.identity);
				}
			}
		}

		public override void Stop()
		{
			WriteStacksToZdo(0);
			((StatusEffect)this).Stop();
		}

		private void WriteStacksToZdo(int stacks)
		{
			try
			{
				if (!((Object)(object)base.m_character == (Object)null) && !((Object)(object)base.m_character.m_nview == (Object)null) && base.m_character.m_nview.IsValid())
				{
					ZDO zDO = base.m_character.m_nview.GetZDO();
					if (zDO != null)
					{
						zDO.Set("nz_bleed_stacks", stacks);
					}
				}
			}
			catch
			{
			}
		}
	}
	public static class SE_BleedingSetup
	{
		public static void Init()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			SE_Bleeding sE_Bleeding = ScriptableObject.CreateInstance<SE_Bleeding>();
			CustomStatusEffect val = new CustomStatusEffect((StatusEffect)(object)sE_Bleeding, true);
			ItemManager.Instance.AddStatusEffect(val);
			Debug.Log((object)"[NazhikaCore] SE_Bleeding registrado (ZDO stacks sync).");
		}
	}
	public class SE_Blindness : StatusEffect
	{
		private GameObject blackoutCanvas;

		private Image blackoutImage;

		private float fadeSpeed = 2f;

		private float targetAlpha = 0.95f;

		public SE_Blindness()
		{
			((Object)this).name = "SE_Blindness";
			base.m_name = "Blindness";
			base.m_tooltip = "Estás cegado. Tu visión se oscurece.";
			base.m_icon = IconHelper.Load("Blindness.png");
			base.m_cooldownIcon = true;
			base.m_ttl = 6f;
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
			Player val = (Player)(object)((character is Player) ? character : null);
			if (val != null && (Object)(object)val == (Object)(object)Player.m_localPlayer)
			{
				CreateBlackout();
			}
		}

		public override void UpdateStatusEffect(float dt)
		{
			//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_0023: 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)
			((StatusEffect)this).UpdateStatusEffect(dt);
			if ((Object)(object)blackoutImage != (Object)null)
			{
				Color color = ((Graphic)blackoutImage).color;
				color.a = Mathf.MoveTowards(color.a, targetAlpha, fadeSpeed * dt);
				((Graphic)blackoutImage).color = color;
			}
		}

		public override void Stop()
		{
			RemoveBlackout();
		}

		private void CreateBlackout()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_009f: 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_00c1: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)blackoutCanvas != (Object)null))
			{
				blackoutCanvas = new GameObject("Naz_BlindnessCanvas");
				Canvas val = blackoutCanvas.AddComponent<Canvas>();
				val.renderMode = (RenderMode)0;
				val.sortingOrder = 9999;
				CanvasGroup val2 = blackoutCanvas.AddComponent<CanvasGroup>();
				val2.blocksRaycasts = false;
				val2.interactable = false;
				GameObject val3 = new GameObject("Naz_BlindnessImage");
				val3.transform.SetParent(blackoutCanvas.transform, false);
				blackoutImage = val3.AddComponent<Image>();
				((Graphic)blackoutImage).color = new Color(0f, 0f, 0f, 0f);
				RectTransform rectTransform = ((Graphic)blackoutImage).rectTransform;
				rectTransform.anchorMin = Vector2.zero;
				rectTransform.anchorMax = Vector2.one;
				rectTransform.offsetMin = Vector2.zero;
				rectTransform.offsetMax = Vector2.zero;
				Object.DontDestroyOnLoad((Object)(object)blackoutCanvas);
			}
		}

		private void RemoveBlackout()
		{
			if ((Object)(object)blackoutCanvas != (Object)null)
			{
				Object.Destroy((Object)(object)blackoutCanvas);
				blackoutCanvas = null;
				blackoutImage = null;
			}
		}
	}
	public static class SE_BlindnessSetup
	{
		public static void Init()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			SE_Blindness sE_Blindness = ScriptableObject.CreateInstance<SE_Blindness>();
			CustomStatusEffect val = new CustomStatusEffect((StatusEffect)(object)sE_Blindness, true);
			ItemManager.Instance.AddStatusEffect(val);
			Debug.Log((object)"[NazhikaCore] SE_Blindness registrado correctamente.");
		}
	}
	public class SE_BloodBurst : StatusEffect
	{
		public static readonly int NameHash = StringExtensionMethods.GetStableHashCode("SE_BloodBurst");

		private const float RadiusMeters = 60f;

		private const float InsaneDamage = 100f;

		private const bool DebugLogs = true;

		public SE_BloodBurst()
		{
			((Object)this).name = "SE_BloodBurst";
			base.m_name = "BloodBurst";
			base.m_icon = IconHelper.Load("bloodburst.png");
			base.m_tooltip = "Detona sangrados cercanos.";
			base.m_ttl = 1f;
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
			BloodBurstNet.EnsureRegisteredRobust();
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				ExecuteServer(character);
			}
			else
			{
				BloodBurstNet.RequestServerExecute(character);
			}
			base.m_time = base.m_ttl;
		}

		internal static void ExecuteServer(Character caster)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)caster == (Object)null || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			Vector3 position = ((Component)caster).transform.position;
			List<Character> list = new List<Character>();
			Character.GetCharactersInRange(position, 60f, list);
			int num = 0;
			Debug.Log((object)$"[NazhikaCore/BloodBurst][SERVER][START] caster={((Object)caster).name} found={list.Count}");
			foreach (Character item in list)
			{
				if ((Object)(object)item == (Object)null || (Object)(object)item == (Object)(object)caster || item.IsDead() || (Object)(object)item.m_nview == (Object)null || !item.m_nview.IsValid())
				{
					continue;
				}
				int num2 = 0;
				try
				{
					ZDO zDO = item.m_nview.GetZDO();
					if (zDO != null)
					{
						num2 = zDO.GetInt("nz_bleed_stacks", 0);
					}
				}
				catch
				{
				}
				if (num2 <= 0)
				{
					Debug.Log((object)("[NazhikaCore/BloodBurst][SERVER][SKIP] " + ((Object)item).name + " sin nz_bleed_stacks"));
					continue;
				}
				SEMan sEMan = item.GetSEMan();
				if (sEMan == null)
				{
					continue;
				}
				float num3 = 100f;
				float health = item.GetHealth();
				float num4 = Mathf.Max(0f, health - num3);
				item.SetHealth(num4);
				try
				{
					ZDO zDO2 = item.m_nview.GetZDO();
					if (zDO2 != null)
					{
						zDO2.Set("nz_bleed_stacks", 0);
					}
				}
				catch
				{
				}
				BleedApplyRPC.RequestCancelBleed(item);
				Vector3 centerPoint = item.GetCenterPoint();
				BloodBurstNet.TryBroadcastFx(centerPoint);
				num++;
				Debug.Log((object)$"[NazhikaCore/BloodBurst][SERVER][HIT] {((Object)item).name} zdoStacks={num2} dmg={num3} hpBefore={health} hpAfter={num4}");
			}
			Debug.Log((object)$"[NazhikaCore/BloodBurst][SERVER][END] afectados={num}");
		}

		internal static void ExecuteServerAtPosition(Vector3 center)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: 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_0141: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || ZDOMan.instance == null)
			{
				return;
			}
			int num = 0;
			List<ZDO> list = new List<ZDO>();
			Vector2i zone = ZoneSystem.GetZone(center);
			ZDOMan.instance.FindSectorObjects(zone, 2, 0, list, (List<ZDO>)null);
			Debug.Log((object)$"[BloodBurst][SERVER][START] pos={center} zdos={list.Count}");
			foreach (ZDO item in list)
			{
				if (item == null)
				{
					continue;
				}
				float num2 = Vector3.Distance(item.GetPosition(), center);
				if (num2 > 60f)
				{
					continue;
				}
				int num3 = 0;
				try
				{
					num3 = item.GetInt("nz_bleed_stacks", 0);
				}
				catch
				{
				}
				if (num3 <= 0)
				{
					continue;
				}
				float num4 = 0f;
				try
				{
					num4 = item.GetFloat(ZDOVars.s_health, 0f);
				}
				catch
				{
				}
				if (!(num4 <= 0f))
				{
					float num5 = Mathf.Max(0f, num4 - 90000f);
					try
					{
						item.Set(ZDOVars.s_health, num5);
						item.Set("nz_bleed_stacks", 0);
					}
					catch
					{
						continue;
					}
					BleedApplyRPC.RequestCancelBleedByZDO(item.m_uid);
					BloodBurstNet.TryBroadcastFx(item.GetPosition());
					num++;
					Debug.Log((object)$"[BloodBurst][SERVER][HIT] zdo={item.m_uid} stacks={num3} hpBefore={num4} hpAfter={num5}");
				}
			}
			Debug.Log((object)$"[BloodBurst][SERVER][END] afectados={num}");
		}
	}
	internal static class BloodBurstNet
	{
		private class RegRunner : MonoBehaviour
		{
			[CompilerGenerated]
			private sealed class <Loop>d__2 : IEnumerator<object>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private object <>2__current;

				public RegRunner <>4__this;

				private float <t>5__2;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0051: Unknown result type (might be due to invalid IL or missing references)
					//IL_005b: Expected O, but got Unknown
					int num = <>1__state;
					RegRunner regRunner = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<t>5__2 = 0f;
						break;
					case 1:
						<>1__state = -1;
						break;
					}
					if (<t>5__2 < 2f && !_registered)
					{
						if (ZRoutedRpc.instance == null)
						{
							<t>5__2 += 0.1f;
							<>2__current = (object)new WaitForSeconds(0.1f);
							<>1__state = 1;
							return true;
						}
						EnsureRegisteredNow();
					}
					regRunner._running = false;
					return false;
				}

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

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

			private bool _running;

			public void Kick()
			{
				if (!_running)
				{
					_running = true;
					((MonoBehaviour)this).StartCoroutine(Loop());
				}
			}

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

		internal const string RpcFxName = "NazhikaCore_BloodBurstFx";

		internal const string RpcRequestName = "NazhikaCore_BloodBurst_Request";

		private const bool DebugLogs = true;

		private static bool _registered;

		private static GameObject _regRunnerGo;

		private static RegRunner _regRunner;

		public static void Init(Harmony harmony)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(ZNet), "Start", (Type[])null, (Type[])null);
			HarmonyMethod val = new HarmonyMethod(typeof(BloodBurstNet), "ZNet_Start_Postfix", (Type[])null);
			harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Debug.Log((object)"[NazhikaCore/BloodBurstNet] Init OK");
		}

		private static void ZNet_Start_Postfix()
		{
			EnsureRegisteredRobust();
		}

		public static void EnsureRegisteredRobust()
		{
			if (!_registered)
			{
				if (ZRoutedRpc.instance != null)
				{
					EnsureRegisteredNow();
					return;
				}
				EnsureRegRunner();
				_regRunner.Kick();
			}
		}

		private static void EnsureRegRunner()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			if (!((Object)(object)_regRunner != (Object)null))
			{
				_regRunnerGo = GameObject.Find("NazhikaCore_BloodBurst_RegRunner");
				if ((Object)(object)_regRunnerGo == (Object)null)
				{
					_regRunnerGo = new GameObject("NazhikaCore_BloodBurst_RegRunner");
					Object.DontDestroyOnLoad((Object)(object)_regRunnerGo);
				}
				_regRunner = _regRunnerGo.GetComponent<RegRunner>();
				if ((Object)(object)_regRunner == (Object)null)
				{
					_regRunner = _regRunnerGo.AddComponent<RegRunner>();
				}
			}
		}

		private static void EnsureRegisteredNow()
		{
			if (!_registered && ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.Register<Vector3>("NazhikaCore_BloodBurstFx", (Action<long, Vector3>)RPC_SpawnFx);
				ZRoutedRpc.instance.Register<ZDOID>("NazhikaCore_BloodBurst_Request", (Action<long, ZDOID>)RPC_RequestBurst);
				_registered = true;
				Debug.Log((object)"[NazhikaCore/BloodBurstNet] RPCs registrados: FX=NazhikaCore_BloodBurstFx, REQ=NazhikaCore_BloodBurst_Request");
			}
		}

		public static void RequestServerExecute(Character caster)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			EnsureRegisteredRobust();
			if (ZRoutedRpc.instance == null || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			ZDOID val = ZDOID.None;
			try
			{
				if ((Object)(object)caster != (Object)null && (Object)(object)caster.m_nview != (Object)null && caster.m_nview.IsValid())
				{
					ZDO zDO = caster.m_nview.GetZDO();
					if (zDO != null)
					{
						val = zDO.m_uid;
					}
				}
			}
			catch
			{
			}
			if (val == ZDOID.None)
			{
				Debug.LogWarning((object)"[NazhikaCore/BloodBurstNet] Request abort: caster ZDOID None");
				return;
			}
			long serverPeerID = ZRoutedRpc.instance.GetServerPeerID();
			ZRoutedRpc.instance.InvokeRoutedRPC(serverPeerID, ZDOID.None, "NazhikaCore_BloodBurst_Request", new object[1] { val });
		}

		public static bool TryBroadcastFx(Vector3 pos)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			EnsureRegisteredRobust();
			if (ZRoutedRpc.instance == null)
			{
				return false;
			}
			try
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "NazhikaCore_BloodBurstFx", new object[1] { pos });
				return true;
			}
			catch (Exception arg)
			{
				Debug.LogWarning((object)$"[NazhikaCore/BloodBurstNet] BroadcastFx ex: {arg}");
				return false;
			}
		}

		private static void RPC_RequestBurst(long sender, ZDOID casterZdo)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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)
			if (!((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer())
			{
				Debug.Log((object)$"[NazhikaCore/BloodBurstNet] Server request sender={sender} casterZdo={casterZdo}");
				ZNetPeer peer = ZNet.instance.GetPeer(sender);
				if (peer == null)
				{
					Debug.LogWarning((object)$"[NazhikaCore/BloodBurstNet] Peer {sender} no encontrado");
					return;
				}
				Vector3 refPos = peer.m_refPos;
				Debug.Log((object)$"[NazhikaCore/BloodBurstNet] Ejecutando desde pos={refPos}");
				SE_BloodBurst.ExecuteServerAtPosition(refPos);
			}
		}

		private static void RPC_SpawnFx(long sender, Vector3 pos)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsDedicated())
			{
				BloodBurstFxFactory.SpawnAtRobust(pos);
			}
		}
	}
	internal static class BloodBurstFxFactory
	{
		private class FxRunner : MonoBehaviour
		{
			[CompilerGenerated]
			private sealed class <Loop>d__3 : IEnumerator<object>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private object <>2__current;

				public FxRunner <>4__this;

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

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

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

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

				private bool MoveNext()
				{
					//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_002e: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					FxRunner fxRunner = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						break;
					case 1:
						<>1__state = -1;
						break;
					}
					if (fxRunner._queue.Count > 0)
					{
						Vector3 pos = fxRunner._queue.Dequeue();
						<>2__current = fxRunner.SpawnWithRetry(pos);
						<>1__state = 1;
						return true;
					}
					fxRunner._running = false;
					return false;
				}

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

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

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

				private object <>2__current;

				public Vector3 pos;

				private float <t>5__2;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0028: Unknown result type (might be due to invalid IL or missing references)
					//IL_0032: Expected O, but got Unknown
					//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bd: Expected O, but got Unknown
					//IL_006d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0072: Unknown result type (might be due to invalid IL or missing references)
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(0.05f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<t>5__2 = 0f;
						break;
					case 2:
						<>1__state = -1;
						break;
					}
					if (<t>5__2 < 3f)
					{
						if ((Object)(object)ZNetScene.instance != (Object)null)
						{
							GameObject vanillaPrefab = GetVanillaPrefab();
							if ((Object)(object)vanillaPrefab != (Object)null)
							{
								GameObject val = Object.Instantiate<GameObject>(vanillaPrefab, pos, Quaternion.identity);
								if ((Object)(object)val != (Object)null)
								{
									PruneAndScaleInstance(val);
									ForceActivate(val);
									val.SetActive(true);
									return false;
								}
							}
						}
						<t>5__2 += 0.1f;
						<>2__current = (object)new WaitForSeconds(0.1f);
						<>1__state = 2;
						return true;
					}
					return false;
				}

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

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

			private readonly Queue<Vector3> _queue = new Queue<Vector3>();

			private bool _running;

			public void Enqueue(Vector3 pos)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				_queue.Enqueue(pos);
				if (!_running)
				{
					_running = true;
					((MonoBehaviour)this).StartCoroutine(Loop());
				}
			}

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

			[IteratorStateMachine(typeof(<SpawnWithRetry>d__4))]
			private IEnumerator SpawnWithRetry(Vector3 pos)
			{
				//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)
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <SpawnWithRetry>d__4(0)
				{
					pos = pos
				};
			}
		}

		private const string VanillaFxName = "fx_CharredStone_Destruction";

		private static GameObject _vanillaPrefab;

		private static readonly string[] KeepKeywords = new string[3] { "skull", "smoke", "glow" };

		private static GameObject _runnerGo;

		private static FxRunner _runner;

		public static void SpawnAtRobust(Vector3 pos)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			EnsureRunner();
			_runner.Enqueue(pos);
		}

		private static void EnsureRunner()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			if (!((Object)(object)_runner != (Object)null))
			{
				_runnerGo = GameObject.Find("NazhikaCore_BloodBurst_FxRunner");
				if ((Object)(object)_runnerGo == (Object)null)
				{
					_runnerGo = new GameObject("NazhikaCore_BloodBurst_FxRunner");
					Object.DontDestroyOnLoad((Object)(object)_runnerGo);
				}
				_runner = _runnerGo.GetComponent<FxRunner>();
				if ((Object)(object)_runner == (Object)null)
				{
					_runner = _runnerGo.AddComponent<FxRunner>();
				}
			}
		}

		private static GameObject GetVanillaPrefab()
		{
			if ((Object)(object)_vanillaPrefab != (Object)null)
			{
				return _vanillaPrefab;
			}
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return null;
			}
			_vanillaPrefab = ZNetScene.instance.GetPrefab("fx_CharredStone_Destruction");
			return _vanillaPrefab;
		}

		private static void PruneAndScaleInstance(GameObject fxInstance)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)fxInstance == (Object)null)
			{
				return;
			}
			int num = 0;
			Transform[] componentsInChildren = fxInstance.GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && IsKeepName(((Object)val).name))
				{
					num++;
				}
			}
			if (num <= 0)
			{
				return;
			}
			DisableNonKeepBranches(fxInstance.transform);
			Transform[] componentsInChildren2 = fxInstance.GetComponentsInChildren<Transform>(true);
			foreach (Transform val2 in componentsInChildren2)
			{
				if ((Object)(object)val2 != (Object)null && IsKeepName(((Object)val2).name))
				{
					val2.localScale *= 0.5f;
				}
			}
		}

		private static void DisableNonKeepBranches(Transform root)
		{
			for (int i = 0; i < root.childCount; i++)
			{
				Transform child = root.GetChild(i);
				if (!((Object)(object)child == (Object)null) && !BranchHasKeep(child))
				{
					((Component)child).gameObject.SetActive(false);
				}
			}
		}

		private static bool BranchHasKeep(Transform t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return false;
			}
			if (IsKeepName(((Object)t).name))
			{
				return true;
			}
			for (int i = 0; i < t.childCount; i++)
			{
				if (BranchHasKeep(t.GetChild(i)))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsKeepName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			string text = name.ToLowerInvariant();
			for (int i = 0; i < KeepKeywords.Length; i++)
			{
				if (text.Contains(KeepKeywords[i]))
				{
					return true;
				}
			}
			return false;
		}

		private static void ForceActivate(GameObject root)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)root))
			{
				Transform[] componentsInChildren = root.GetComponentsInChildren<Transform>(true);
				foreach (Transform val in componentsInChildren)
				{
					((Component)val).gameObject.SetActive(true);
				}
				ParticleSystem[] componentsInChildren2 = root.GetComponentsInChildren<ParticleSystem>(true);
				foreach (ParticleSystem val2 in componentsInChildren2)
				{
					EmissionModule emission = val2.emission;
					((EmissionModule)(ref emission)).enabled = true;
					val2.Clear(true);
					val2.Play(true);
				}
			}
		}
	}
	public static class SE_BloodBurstSetup
	{
		public static void Init()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			SE_BloodBurst sE_BloodBurst = ScriptableObject.CreateInstance<SE_BloodBurst>();
			CustomStatusEffect val = new CustomStatusEffect((StatusEffect)(object)sE_BloodBurst, true);
			ItemManager.Instance.AddStatusEffect(val);
			BloodBurstNet.EnsureRegisteredRobust();
			Debug.Log((object)"[NazhikaCore] SE_BloodBurst registrado (ZDO detect bleeding; client->server request; FX Everybody).");
		}
	}
	public class SE_Curse : StatusEffect
	{
		private float tickTimer;

		private float fxTimer;

		private float damagePerTick = 5f;

		private float tickInterval = 2f;

		public SE_Curse()
		{
			((Object)this).name = "SE_Curse";
			base.m_name = "Curse";
			base.m_tooltip = "Estas maldito, el daño que haga se te devolvera.";
			base.m_icon = IconHelper.Load("curse.png");
			base.m_ttl = 5f;
		}

		public override void UpdateStatusEffect(float dt)
		{
		}
	}
	public static class SE_CurseSetup
	{
		public static void Init()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			SE_Curse sE_Curse = ScriptableObject.CreateInstance<SE_Curse>();
			CustomStatusEffect val = new CustomStatusEffect((StatusEffect)(object)sE_Curse, true);
			ItemManager.Instance.AddStatusEffect(val);
			Debug.Log((object)"[NazhikaCore] SE_Curse registrado correctamente.");
		}
	}
	public class SE_FocusShot : StatusEffect
	{
		public const string InternalName = "SE_FocusShot";

		public static readonly int NameHash = StringExtensionMethods.GetStableHashCode("SE_FocusShot");

		public const string ZdoKeyActive = "focusshot_active";

		private Character _ch;

		public SE_FocusShot()
		{
			((Object)this).name = "SE_FocusShot";
			base.m_name = "Focus Shot";
			base.m_icon = IconHelper.Load("focusshot.png");
			base.m_ttl = 15f;
			base.m_tooltip = "Concentración del arquero: más daño al próximo disparo de arco.";
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
			_ch = character;
			Player val = (Player)(object)((character is Player) ? character : null);
			if ((Object)(object)val != (Object)null)
			{
				ZNetView component = ((Component)val).GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.IsValid() && component.GetZDO() != null && component.IsOwner())
				{
					component.GetZDO().Set("focusshot_active", 1);
					Debug.Log((object)("[SE_FocusShot] ZDO flag set → focusshot_active=1 para " + val.GetPlayerName()));
				}
			}
		}

		public override void UpdateStatusEffect(float dt)
		{
			((StatusEffect)this).UpdateStatusEffect(dt);
			base.m_tooltip = "Focus Shot activo (" + Mathf.CeilToInt(GetRemainingTTL()) + "s)";
		}

		public override void Stop()
		{
			Character ch = _ch;
			Player val = (Player)(object)((ch is Player) ? ch : null);
			if ((Object)(object)val != (Object)null)
			{
				ZNetView component = ((Component)val).GetComponent<ZNetView>();
				if ((Object)(object)component != (Object)null && component.IsValid() && component.GetZDO() != null && component.IsOwner())
				{
					component.GetZDO().Set("focusshot_active", 0);
					Debug.Log((object)("[SE_FocusShot] ZDO flag cleared → focusshot_active=0 para " + val.GetPlayerName()));
				}
				long playerID = val.GetPlayerID();
				FocusShotRuntime.RaiseFocusRemoved(playerID);
				PlayerClassBase @class = ClassManager.GetClass(val);
				if (@class != null)
				{
					@class.TryBeginCooldown(val);
					SkillsUI.StartCooldown(@class.CooldownSeconds);
					Log.Info($"[SE_FocusShot] Buff terminado → cooldown de {@class.CooldownSeconds}s iniciado para {val.GetPlayerName()}");
				}
			}
			((StatusEffect)this).Stop();
		}

		private float GetRemainingTTL()
		{
			return Mathf.Max(0f, base.m_ttl - base.m_time);
		}
	}
	public static class SE_FocusShotSetup
	{
		public static void Init()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			SE_FocusShot sE_FocusShot = ScriptableObject.CreateInstance<SE_FocusShot>();
			CustomStatusEffect val = new CustomStatusEffect((StatusEffect)(object)sE_FocusShot, true);
			ItemManager.Instance.AddStatusEffect(val);
			Debug.Log((object)"[NazhikaCore] ✅ SE_FocusShot registrado en Jotunn");
		}
	}
	public static class FocusShotRuntime
	{
		public static event Action<long> FocusRemoved;

		public static void RaiseFocusRemoved(long playerId)
		{
			try
			{
				if (FocusShotRuntime.FocusRemoved != null)
				{
					FocusShotRuntime.FocusRemoved(playerId);
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[FocusShot] FocusRemoved event error: " + ex));
			}
		}
	}
	public class SE_LavaRocks : StatusEffect
	{
		private class NoDamageCleaner : MonoBehaviour
		{
			private GameObject _root;

			private int _frames;

			public void Run(GameObject r, int frames)
			{
				_root = r;
				_frames = frames;
			}

			private void LateUpdate()
			{
				if ((Object)(object)_root == (Object)null)
				{
					Object.Destroy((Object)(object)this);
					return;
				}
				CleanOnce(_root);
				if (--_frames <= 0)
				{
					Object.Destroy((Object)(object)this);
				}
			}
		}

		public const string InternalName = "SE_LavaRocks";

		public static readonly int NameHash = StringExtensionMethods.GetStableHashCode("SE_LavaRocks");

		private const KeyCode ToggleKey = 57;

		private const string LavaRockPrefabName = "LavaRock";

		private const int RocksCount = 4;

		private const float CircleYOffset = 0.06f;

		private const float SymbolWorldSize = 6f;

		private static readonly Vector3 MarkerScale = Vector3.one;

		private const string MarkerTextureFile = "sealSymbol3.png";

		private const float SpawnRadius = 6f;

		private const float SpawnYOffset = 0.15f;

		private const float MinCenterDistance = 0.9f;

		private Character _ch;

		private GameObject _marker;

		private GameObject _symbol;

		private bool _spawnReadyShown;

		public SE_LavaRocks()
		{
			((Object)this).name = "SE_LavaRocks";
			base.m_name = "Lava Rocks";
			base.m_icon = IconHelper.Load("LavaRocks.png");
			base.m_tooltip = "Apunta y haz clic derecho para invocar rocas de lava. Esc: cancelar.";
			base.m_ttl = 8f;
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
			_ch = character;
			Character ch = _ch;
			Player val = (Player)(object)((ch is Player) ? ch : null);
			if (val != null && (Object)(object)Player.m_localPlayer == (Object)(object)val)
			{
				EnsureMarker(val);
				_marker.SetActive(true);
				SnapMarkerToMouse();
				_spawnReadyShown = true;
			}
		}

		public override void UpdateStatusEffect(float dt)
		{
			//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_0113: Unknown result type (might be due to invalid IL or missing references)
			((StatusEffect)this).UpdateStatusEffect(dt);
			base.m_tooltip = $"Lava Rocks ({Mathf.CeilToInt(Mathf.Max(0f, base.m_ttl - base.m_time))}s) — RMB: rocas, LMB/Esc: cancelar";
			Character ch = _ch;
			Player val = (Player)(object)((ch is Player) ? ch : null);
			if (val == null || (Object)(object)Player.m_localPlayer != (Object)(object)val)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)57))
			{
				EnsureMarker(val);
				_marker.SetActive(!_marker.activeSelf);
			}
			if ((Object)(object)_marker == (Object)null)
			{
				return;
			}
			if (_marker.activeSelf)
			{
				if (Input.GetMouseButtonDown(0) || Input.GetKeyDown((KeyCode)27))
				{
					_marker.SetActive(false);
					return;
				}
				SnapMarkerToMouse();
				if (Input.GetMouseButtonDown(1))
				{
					if ((Object)(object)((Character)val).m_nview != (Object)null && ((Character)val).m_nview.IsValid())
					{
						((Character)val).m_nview.InvokeRPC(ZNetView.Everybody, "RPC_Nazhika_PlayCheer", Array.Empty<object>());
					}
					Vector3 position = _marker.transform.position;
					SpawnLavaRocks(position, 6f, 4);
					_marker.SetActive(false);
					base.m_time = base.m_ttl;
				}
			}
			else if (!_spawnReadyShown)
			{
				EnsureMarker(val);
				_marker.SetActive(true);
				SnapMarkerToMouse();
				_spawnReadyShown = true;
			}
		}

		public override void Stop()
		{
			((StatusEffect)this).Stop();
			Character character = base.m_character;
			Player val = (Player)(object)((character is Player) ? character : null);
			if (val != null)
			{
				PlayerClassBase @class = ClassManager.GetClass(val);
				if (@class != null)
				{
					@class.TryBeginCooldown(val);
					SkillsUI.StartCooldown(@class.CooldownSeconds);
				}
			}
			try
			{
				if ((Object)(object)_marker != (Object)null)
				{
					Object.Destroy((Object)(object)_marker);
				}
				_marker = null;
				_symbol = null;
			}
			catch
			{
			}
		}

		private void EnsureMarker(Player owner)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0030: 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_00ad: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			if ((Object)(object)_marker != (Object)null)
			{
				return;
			}
			_marker = new GameObject("LavaRocksMarker_SE");
			_marker.transform.position = ((Component)owner).transform.position;
			_marker.transform.localScale = MarkerScale;
			_marker.SetActive(false);
			_symbol = GameObject.CreatePrimitive((PrimitiveType)5);
			((Object)_symbol).name = "SealSymbol3";
			_symbol.transform.SetParent(_marker.transform, false);
			_symbol.transform.localPosition = new Vector3(0f, 0.06f, 0f);
			_symbol.transform.localRotation = Quaternion.Euler(-90f, 0f, 0f);
			_symbol.transform.localScale = Vector3.one * 6f;
			Renderer component = _symbol.GetComponent<Renderer>();
			Shader val = TryFindShader("Unlit/Transparent", "Sprites/Default", "Legacy Shaders/Transparent/Diffuse", "Particles/Standard Unlit", "Standard");
			if ((Object)(object)component != (Object)null && (Object)(object)val != (Object)null)
			{
				Material val2 = new Material(val);
				val2.mainTexture = (Texture)(object)LoadTexture_NoRef("sealSymbol3.png");
				val2.renderQueue = 3000;
				try
				{
					if (val2.HasProperty("_Cull"))
					{
						val2.SetInt("_Cull", 0);
					}
				}
				catch
				{
				}
				component.material = val2;
			}
			Collider component2 = _symbol.GetComponent<Collider>();
			if ((Object)(object)component2 != (Object)null)
			{
				Object.Destroy((Object)(object)component2);
			}
		}

		private void SnapMarkerToMouse()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			Camera gameCamera = GetGameCamera();
			if (!((Object)(object)gameCamera == (Object)null) && !((Object)(object)_marker == (Object)null))
			{
				Ray val = gameCamera.ScreenPointToRay(Input.mousePosition);
				RaycastHit val2 = default(RaycastHit);
				if (Physics.Raycast(val, ref val2, 500f, -1, (QueryTriggerInteraction)1))
				{
					Vector3 point = ((RaycastHit)(ref val2)).point;
					point.y += 0.06f;
					_marker.transform.position = point;
				}
			}
		}

		private static void SpawnLavaRocks(Vector3 center, float radius, int count)
		{
			//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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab("LavaRock");
			if ((Object)(object)prefab == (Object)null)
			{
				Debug.LogWarning((object)"[SE_LavaRocks] Prefab no encontrado: \"LavaRock\"");
				return;
			}
			Vector3 val2 = default(Vector3);
			for (int i = 0; i < count; i++)
			{
				Vector2 val = Random.insideUnitCircle * radius;
				if (((Vector2)(ref val)).magnitude < 0.9f)
				{
					val = ((Vector2)(ref val)).normalized * 0.9f;
				}
				((Vector3)(ref val2))..ctor(center.x + val.x, center.y, center.z + val.y);
				if (TrySnapToGround(val2, out var snapped))
				{
					val2 = snapped;
				}
				val2.y += 0.15f;
				Quaternion val3 = Quaternion.Euler(0f, Random.Range(0f, 360f), 0f);
				GameObject root = Object.Instantiate<GameObject>(prefab, val2, val3);
				NukeDamageComponents(root);
			}
		}

		private static bool TrySnapToGround(Vector3 near, out Vector3 snapped)
		{
			//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_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_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_0036: 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)
			snapped = near;
			Vector3 val = near + Vector3.up * 25f;
			RaycastHit val2 = default(RaycastHit);
			if (Physics.Raycast(val, Vector3.down, ref val2, 80f, -1, (QueryTriggerInteraction)1))
			{
				snapped = ((RaycastHit)(ref val2)).point;
				return true;
			}
			return false;
		}

		private static void NukeDamageComponents(GameObject root)
		{
			if (Object.op_Implicit((Object)(object)root))
			{
				CleanOnce(root);
				NoDamageCleaner noDamageCleaner = root.AddComponent<NoDamageCleaner>();
				noDamageCleaner.Run(root, 6);
			}
		}

		private static void CleanOnce(GameObject root)
		{
			//IL_001f: 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)
			try
			{
				Aoe[] componentsInChildren = root.GetComponentsInChildren<Aoe>(true);
				foreach (Aoe val in componentsInChildren)
				{
					if (!((Object)(object)val == (Object)null))
					{
						val.m_damage = default(DamageTypes);
						((Behaviour)val).enabled = false;
					}
				}
				Projectile[] componentsInChildren2 = root.GetComponentsInChildren<Projectile>(true);
				foreach (Projectile val2 in componentsInChildren2)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						val2.m_damage = default(DamageTypes);
						((Behaviour)val2).enabled = false;
					}
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[SE_LavaRocks] CleanOnce error: " + ex.Message));
			}
		}

		private static Camera GetGameCamera()
		{
			if ((Object)(object)GameCamera.instance?.m_camera != (Object)null)
			{
				return GameCamera.instance.m_camera;
			}
			return Camera.main;
		}

		private static Shader TryFindShader(params string[] names)
		{
			foreach (string text in names)
			{
				Shader val = Shader.Find(text);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static Texture2D LoadTexture_NoRef(string fileName)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			string text = Path.Combine(Paths.PluginPath, "NazhikaCore", "Assets", "Images", fileName);
			if (!File.Exists(text))
			{
				Debug.LogWarning((object)("[SE_LavaRocks] PNG no encontrado: " + text));
				return Texture2D.whiteTexture;
			}
			byte[] array = File.ReadAllBytes(text);
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			try
			{
				MethodInfo methodInfo = Type.GetType("UnityEngine.ImageConversion, UnityEngine.ImageConversionModule")?.GetMethod("LoadImage", new Type[3]
				{
					typeof(Texture2D),
					typeof(byte[]),
					typeof(bool)
				});
				if (methodInfo != null && (bool)methodInfo.Invoke(null, new object[3] { val, array, false }))
				{
					return val;
				}
			}
			catch
			{
			}
			return Texture2D.whiteTexture;
		}
	}
	public static class SE_LavaRocksSetup
	{
		public static void Init()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			SE_LavaRocks sE_LavaRocks = ScriptableObject.CreateInstance<SE_LavaRocks>();
			ItemManager.Instance.AddStatusEffect(new CustomStatusEffect((StatusEffect)(object)sE_LavaRocks, true));
			Debug.Log((object)"[NazhikaCore] ✅ SE_LavaRocks registrado en Jotunn");
		}
	}
	public class SE_LightningStorm : StatusEffect
	{
		private class NoDamageCleaner : MonoBehaviour
		{
			private GameObject _root;

			private int _frames;

			public void Run(GameObject r, int frames)
			{
				_root = r;
				_frames = frames;
			}

			private void LateUpdate()
			{
				if ((Object)(object)_root == (Object)null)
				{
					Object.Destroy((Object)(object)this);
					return;
				}
				CleanOnce(_root);
				_frames--;
				if (_frames <= 0)
				{
					Object.Destroy((Object)(object)this);
				}
			}
		}

		public const string InternalName = "SE_LightningStorm";

		public static readonly int NameHash = StringExtensionMethods.GetStableHashCode("SE_LightningStorm");

		private const KeyCode ToggleKey = 57;

		private const string LightningPrefabName = "lightningAOE";

		private const float CircleYOffset = 0.06f;

		private const float SymbolWorldSize = 3.5f;

		private static readonly Vector3 MarkerScale = Vector3.one;

		private const float ImmobilizeRadius = 5f;

		private const float ImmobilizeCenterBonus = 0f;

		private const string ImmobilizedName = "ImmobilizedLong";

		private static readonly int ImmobilizedHash = StringExtensionMethods.GetStableHashCode("ImmobilizedLong");

		private Character _ch;

		private GameObject _marker;

		private GameObject _symbol;

		private bool _spawnReadyShown;

		public SE_LightningStorm()
		{
			((Object)this).name = "SE_LightningStorm";
			base.m_name = "Lightning Storm";
			base.m_icon = IconHelper.Load("LightningStorm.png");
			base.m_tooltip = "Apunta y haz clic derecho para invocar rayos. Esc: cancelar.";
			base.m_ttl = 20f;
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
			_ch = character;
			Character ch = _ch;
			Player val = (Player)(object)((ch is Player) ? ch : null);
			if (val != null && (Object)(object)Player.m_localPlayer == (Object)(object)val)
			{
				EnsureMarker(val);
				_marker.SetActive(true);
				SnapMarkerToMouse();
				_spawnReadyShown = true;
			}
		}

		public override void UpdateStatusEffect(float dt)
		{
			//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_0114: Unknown result type (might be due to invalid IL or missing references)
			((StatusEffect)this).UpdateStatusEffect(dt);
			base.m_tooltip = $"Lightning Storm ({Mathf.CeilToInt(Mathf.Max(0f, base.m_ttl - base.m_time))}s) — RMB: rayos, LMB/Esc: cancelar";
			Character ch = _ch;
			Player val = (Player)(object)((ch is Player) ? ch : null);
			if (val == null || (Object)(object)Player.m_localPlayer != (Object)(object)val)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)57))
			{
				EnsureMarker(val);
				_marker.SetActive(!_marker.activeSelf);
			}
			if ((Object)(object)_marker == (Object)null)
			{
				return;
			}
			if (_marker.activeSelf)
			{
				if (Input.GetMouseButtonDown(0) || Input.GetKeyDown((KeyCode)27))
				{
					_marker.SetActive(false);
					return;
				}
				SnapMarkerToMouse();
				if (Input.GetMouseButtonDown(1))
				{
					if ((Object)(object)((Character)val).m_nview != (Object)null && ((Character)val).m_nview.IsValid())
					{
						((Character)val).m_nview.InvokeRPC(ZNetView.Everybody, "RPC_Nazhika_PlayCheer", Array.Empty<object>());
					}
					Vector3 position = _marker.transform.position;
					SpawnLightningBurst(position);
					_marker.SetActive(false);
					base.m_time = base.m_ttl;
				}
			}
			else if (!_spawnReadyShown)
			{
				EnsureMarker(val);
				_marker.SetActive(true);
				SnapMarkerToMouse();
				_spawnReadyShown = true;
			}
		}

		public override void Stop()
		{
			((StatusEffect)this).Stop();
			Character character = base.m_character;
			Player val = (Player)(object)((character is Player) ? character : null);
			if (val != null)
			{
				PlayerClassBase @class = ClassManager.GetClass(val);
				if (@class != null)
				{
					@class.TryBeginCooldown(val);
					SkillsUI.StartCooldown(@class.CooldownSeconds);
				}
			}
			try
			{
				if ((Object)(object)_marker != (Object)null)
				{
					Object.Destroy((Object)(object)_marker);
				}
				_marker = null;
				_symbol = null;
			}
			catch
			{
			}
		}

		private void EnsureMarker(Player owner)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0030: 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_00ad: 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_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			if ((Object)(object)_marker != (Object)null)
			{
				return;
			}
			_marker = new GameObject("LightningMarker_SE");
			_marker.transform.position = ((Component)owner).transform.position;
			_marker.transform.localScale = MarkerScale;
			_marker.SetActive(false);
			_symbol = GameObject.CreatePrimitive((PrimitiveType)5);
			((Object)_symbol).name = "SealSymbol";
			_symbol.transform.SetParent(_marker.transform, false);
			_symbol.transform.localPosition = new Vector3(0f, 0.06f, 0f);
			_symbol.transform.localRotation = Quaternion.Euler(-90f, 0f, 0f);
			_symbol.transform.localScale = Vector3.one * 3.5f;
			Renderer component = _symbol.GetComponent<Renderer>();
			Shader val = TryFindShader("Unlit/Transparent", "Sprites/Default", "Legacy Shaders/Transparent/Diffuse", "Legacy Shaders/Particles/Alpha Blended", "Particles/Standard Unlit", "Standard");
			Material val2 = (Material)((!((Object)(object)val != (Object)null)) ? ((object)(((Object)(object)component != (Object)null) ? (component.material ?? component.sharedMaterial) : null)) : ((object)new Material(val)));
			if ((Object)(object)val2 != (Object)null)
			{
				try
				{
					if (val2.HasProperty("_Cull"))
					{
						val2.SetInt("_Cull", 0);
					}
				}
				catch
				{
				}
				try
				{
					val2.renderQueue = 3000;
				}
				catch
				{
				}
				val2.mainTexture = (Texture)(object)LoadTexture_NoRef("sealSymbol2.png");
				component.material = val2;
			}
			Collider component2 = _symbol.GetComponent<Collider>();
			if ((Object)(object)component2 != (Object)null)
			{
				Object.Destroy((Object)(object)component2);
			}
		}

		private void SnapMarkerToMouse()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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)
			Camera gameCamera = GetGameCamera();
			if (!((Object)(object)gameCamera == (Object)null) && !((Object)(object)_marker == (Object)null))
			{
				Ray val = gameCamera.ScreenPointToRay(Input.mousePosition);
				RaycastHit val2 = default(RaycastHit);
				if (Physics.Raycast(val, ref val2, 500f, -1, (QueryTriggerInteraction)1))
				{
					Vector3 point = ((RaycastHit)(ref val2)).point;
					point.y = ((RaycastHit)(ref val2)).point.y + 0.06f;
					_marker.transform.position = point;
				}
			}
		}

		private void SpawnLightningBurst(Vector3 center)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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)
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab("lightningAOE");
			if ((Object)(object)prefab == (Object)null)
			{
				Debug.LogWarning((object)"[SE_LightningStorm] Prefab no encontrado: \"lightningAOE\"");
				return;
			}
			for (int i = 0; i < 4; i++)
			{
				Vector3 val = center + Random.insideUnitSphere * 4f;
				val.y = center.y;
				GameObject root = Object.Instantiate<GameObject>(prefab, val, Quaternion.identity);
				NukeDamageComponents(root);
				ApplyImmobilizedInRadius(val, 5f);
			}
		}

		private static void TryApplyImmobilized(Character ch)
		{
			if (!((Object)(object)ch == (Object)null) && !ch.IsDead() && !ch.IsPlayer())
			{
				SEMan sEMan = ch.GetSEMan();
				if (sEMan != null && !sEMan.HaveStatusEffect(ImmobilizedHash))
				{
					sEMan.AddStatusEffect(ImmobilizedHash, false, 0, 0f);
				}
			}
		}

		private static void ApplyImmobilizedInRadius(Vector3 center, float radius)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(center, radius, -1, (QueryTriggerInteraction)1);
			if (array == null || array.Length == 0)
			{
				return;
			}
			Vector3 val2 = default(Vector3);
			foreach (Collider val in array)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				Character componentInParent = ((Component)val).GetComponentInParent<Character>();
				if (!((Object)(object)componentInParent == (Object)null))
				{
					Vector3 position = ((Component)componentInParent).transform.position;
					((Vector3)(ref val2))..ctor(center.x, position.y, center.z);
					if (!(Vector3.Distance(position, val2) > radius + 0.15f))
					{
						TryApplyImmobilized(componentInParent);
					}
				}
			}
		}

		private static void NukeDamageComponents(GameObject root)
		{
			if (Object.op_Implicit((Object)(object)root))
			{
				CleanOnce(root);
				NoDamageCleaner noDamageCleaner = root.AddComponent<NoDamageCleaner>();
				noDamageCleaner.Run(root, 6);
			}
		}

		private static void CleanOnce(GameObject root)
		{
			//IL_001f: 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)
			try
			{
				Aoe[] componentsInChildren = root.GetComponentsInChildren<Aoe>(true);
				foreach (Aoe val in componentsInChildren)
				{
					if (!((Object)(object)val == (Object)null))
					{
						val.m_damage = default(DamageTypes);
						((Behaviour)val).enabled = false;
					}
				}
				Projectile[] componentsInChildren2 = root.GetComponentsInChildren<Projectile>(true);
				foreach (Projectile val2 in componentsInChildren2)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						val2.m_damage = default(DamageTypes);
						((Behaviour)val2).enabled = false;
					}
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[SE_LightningStorm] CleanOnce error: " + ex.Message));
			}
		}

		private static Camera GetGameCamera()
		{
			if ((Object)(object)GameCamera.instance?.m_camera != (Object)null)
			{
				return GameCamera.instance.m_camera;
			}
			return Camera.main;
		}

		private static Shader TryFindShader(params string[] names)
		{
			foreach (string text in names)
			{
				Shader val = Shader.Find(text);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static Texture2D LoadTexture_NoRef(string fileName)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			string text = Path.Combine(Paths.PluginPath, "NazhikaCore", "Assets", "Images", fileName);
			if (!File.Exists(text))
			{
				Debug.LogWarning((object)("[SE_LightningStorm] PNG no encontrado: " + text));
				return Texture2D.whiteTexture;
			}
			byte[] array = File.ReadAllBytes(text);
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
			try
			{
				MethodInfo methodInfo = Type.GetType("UnityEngine.ImageConversion, UnityEngine.ImageConversionModule")?.GetMethod("LoadImage", new Type[3]
				{
					typeof(Texture2D),
					typeof(byte[]),
					typeof(bool)
				});
				if (methodInfo != null && (bool)methodInfo.Invoke(null, new object[3] { val, array, false }))
				{
					return val;
				}
			}
			catch
			{
			}
			return Texture2D.whiteTexture;
		}
	}
	public static class SE_LightningStormSetup
	{
		public static void Init()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			SE_LightningStorm sE_LightningStorm = ScriptableObject.CreateInstance<SE_LightningStorm>();
			CustomStatusEffect val = new CustomStatusEffect((StatusEffect)(object)sE_LightningStorm, true);
			ItemManager.Instance.AddStatusEffect(val);
			Debug.Log((object)"[NazhikaCore] ✅ SE_LightningStorm registrado en Jotunn");
		}
	}
	public class SE_MagicRoots : StatusEffect
	{
		private class NoDamageCleaner : MonoBehaviour
		{
			private GameObject _root;

			private int _frames;

			public void Run(GameObject r, int frames)
			{
				_root = r;
				_frames = frames;
			}

			private void LateUpdate()
			{
				if ((Object)(object)_root == (Object)null)
				{
					Object.Destroy((Object)(object)this);
					return;
				}
				CleanOnce(_root);
				if (--_frames <= 0)
				{
					Object.Destroy((Object)(object)this);
				}
			}
		}

		public const string InternalName = "SE_MagicRoots";

		public static readonly int NameHash = StringExtensionMethods.GetStableHashCode("SE_MagicRoots");

		private const KeyCode ToggleKey = 57;

		private const string RootFxPrefab = "fx_RootAshlands";

		private const float CircleYOffset = 0.06f;

		private const float SymbolWorldSize = 12f;

		private static readonly Vector3 MarkerScale = Vector3.one;

		private const float ImmobilizeRadius = 8f;

		private const float ImmobilizeDuration = 10f;

		private const string ImmobilizedName = "ImmobilizedLong";

		private static readonly int ImmobilizedHash = StringExtensionMethods.GetStableHashCode("ImmobilizedLong");

		private static readonly int MagicRootsFxHash = SE_MagicRootsFX_Target.NameHash;

		private Character _ch;

		private GameObject _marker;

		private GameObject _symbol;

		private bool _spawnReadyShown;

		public SE_MagicRoots()
		{
			((Object)this).name = "SE_MagicRoots";
			base.m_name = "Magic Roots";
			base.m_icon = IconHelper.Load("MagicRoots.png");
			base.m_tooltip = "Apunta y haz clic derecho para invocar raíces. Esc: cancelar.";
			base.m_ttl = 5f;
		}

		public override void Setup(Character character)
		{
			((StatusEffect)this).Setup(character);
			_ch = character;
			Character ch = _ch;
			Player val = (Player)(object)((ch is Player) ? ch : null);
			if (val != null && (Object)(object)Player.m_localPlayer == (Object)(object)val)
			{
				EnsureMarker(val);
				_marker.SetActive(true);
				SnapMarkerToMouse();
				_spawnReadyShown = true;
			}
		}

		public override void UpdateStatusEffect(float dt)
		{
			//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_0114: Unknown result type (might be due to invalid IL or missing references)
			((StatusEffect)this).UpdateStatusEffect(dt);
			base.m_tooltip = $"Magic Roots ({Mathf.CeilToInt(Mathf.Max(0f, base.m_ttl - base.m_time))}s) — RMB: raíces, LMB/Esc: cancelar";
			Character ch = _ch;
			Player val = (Player)(object)((ch is Player) ? ch : null);
			if (val == null || (Object)(object)Player.m_localPlayer != (Object)(object)val)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)57))
			{
				EnsureMarker(val);
				_marker.SetActive(!_marker.activeSelf);
			}
			if ((Object)(object)_marker == (Object)null)
			{
				return;
			}
			if (_marker.activeSelf)
			{
				if (Input.GetMouseButtonDown(0) || Input.GetKeyDown((KeyCode)27))
				{
					_marker.SetActive(false);
					return;
				}
				SnapMarkerToMouse();
				if (Input.GetMouseButtonDown(1))
				{
					if ((Object)(object)((Character)val).m_nview != (Object)null && ((Character)val).m_nview.IsValid())
					{
						((Character)val).m_nview.InvokeRPC(ZNetView.Everybody, "RPC_Nazhika_PlayCheer", Array.Empty<object>());
					}
					Vector3 position = _marker.transform.position;
					SpawnRoots(position);
					_marker.SetActive(false);
					base.m_time = base.m_ttl;
				}
			}
			else if (!_spawnReadyShown)
			{
				EnsureMarker(val);
				_marker.SetActive(true);
				SnapMarkerToMouse();
				_spawnReadyShown = true;
			}
		}

		public override void Stop()
		{
			((StatusEffect)this).Stop();
			Character character = base.m_character;
			Player val = (Player)(object)((character is Player) ? character : null);
			if (val != null)
			{
				PlayerClassBase @class = ClassManager.GetClass(val);
				if (@class != null)
				{
					@class.TryBeginCooldown(val);
					SkillsUI.StartCooldown(@class.CooldownSeconds);
				}
			}
			try
			{
				if ((Object)(object)_marker != (Object)null)
				{
					Object.Destroy((Object)(object)_marker);
				}
				_marker = null;
				_symbol = null;
			}
			catch
			{
			}
		}

		private void EnsureMarker(Player owner)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0030: 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_00ad: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			if (!((Object)(object)_marker != (Object)null))
			{
				_marker = new GameObject("MagicRootsMarker_SE");
				_marker.transform.position = ((Component)owner).transform.position;
				_marker.transform.localScale = MarkerScale;
				_marker.SetActive(false);
				_symbol = GameObject.CreatePrimitive((PrimitiveType)5);
				((Object)_symbol).name = "RootSymbol";
				_symbol.transform.SetParent(_marker.transform, false);
				_symbol.transform.localPosition = new Vector3(0f, 0.06f, 0f);
				_symbol.transform.localRotation = Quaternion.Euler(-90f, 0f, 0f);
				_symbol.transform.localScale = Vector3.one * 12f;
				Renderer component = _symbol.GetComponent<Renderer>();
				Shader val = TryFindShader("Unlit/Transparent", "Sprites/Default", "Legacy Shaders/Transparent/Diffuse", "Particles/Standard Unlit", "Standard");
				if ((Object)(object)component != (Object)null && (Object)(object)val != (Object)null)
				{
					Material val2 = new Material(val);
					val2.mainTexture = (Texture)(object)LoadTexture_NoRef("sealSymbol2.png");
					val2.renderQueue = 3000;
					component.material = val2;
				}
				Collider component2 = _symbol.GetComponent<Collider>();
				if ((Object)(object)component2 != (Object)null)
				{
					Object.Destroy((Object)(object)component2);
				}
			}
		}

		private void SnapMarkerToMouse()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			Camera gameCamera = GetGameCamera();
			if (!((Object)(object)gameCamera == (Object)null) && !((Object)(object)_marker == (Object)null))
			{
				Ray val = gameCamera.ScreenPointToRay(Input.mousePosition);
				RaycastHit val2 = default(RaycastHit);
				if (Physics.Raycast(val, ref val2, 500f, -1, (QueryTriggerInteraction)1))
				{
					Vector3 point = ((RaycastHit)(ref val2)).point;
					point.y += 0.06f;
					_marker.transform.position = point;
				}
			}
		}

		private void SpawnRoots(Vector3 center)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (m