using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
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 System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JetBrains.Annotations;
using Jotunn;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Testing2")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Testing2")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("55CC6F29-0D48-4124-93BF-F657DE656B82")]
[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]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace YourModName
{
	public enum ItemRarity
	{
		Common,
		Uncommon,
		Rare,
		Epic,
		Legendary
	}
	public static class RarityData
	{
		public static readonly Dictionary<ItemRarity, RarityInfo> Info = new Dictionary<ItemRarity, RarityInfo>
		{
			{
				ItemRarity.Common,
				new RarityInfo
				{
					Name = "Common",
					Color = new Color(1f, 1f, 1f),
					StatBonus = 0f,
					SlotCount = 0,
					Weight = 50f
				}
			},
			{
				ItemRarity.Uncommon,
				new RarityInfo
				{
					Name = "Uncommon",
					Color = new Color(0.3f, 0.85f, 0.3f),
					StatBonus = 0.05f,
					SlotCount = 1,
					Weight = 25f
				}
			},
			{
				ItemRarity.Rare,
				new RarityInfo
				{
					Name = "Rare",
					Color = new Color(0.3f, 0.5f, 1f),
					StatBonus = 0.1f,
					SlotCount = 2,
					Weight = 15f
				}
			},
			{
				ItemRarity.Epic,
				new RarityInfo
				{
					Name = "Epic",
					Color = new Color(0.7f, 0.3f, 1f),
					StatBonus = 0.15f,
					SlotCount = 3,
					Weight = 5f
				}
			},
			{
				ItemRarity.Legendary,
				new RarityInfo
				{
					Name = "Legendary",
					Color = new Color(1f, 0.85f, 0.1f),
					StatBonus = 0.2f,
					SlotCount = 4,
					Weight = 0f
				}
			}
		};

		public static ItemRarity RollRarity()
		{
			float num = 0f;
			foreach (KeyValuePair<ItemRarity, RarityInfo> item in Info)
			{
				num += item.Value.Weight;
			}
			float num2 = Random.Range(0f, num);
			float num3 = 0f;
			foreach (KeyValuePair<ItemRarity, RarityInfo> item2 in Info)
			{
				num3 += item2.Value.Weight;
				if (num2 < num3)
				{
					return item2.Key;
				}
			}
			return ItemRarity.Common;
		}
	}
	public class RarityInfo
	{
		public string Name;

		public Color Color;

		public float StatBonus;

		public int SlotCount;

		public float Weight;
	}
	public class RarityItemData
	{
		public ItemRarity Rarity;

		public int SlotCount;

		public List<string> InsertedScrollIds;

		public float BasePierce;

		public float BaseBlunt;

		public float BaseSlash;

		public float BaseFire;

		public float BaseFrost;

		public float BaseLightning;

		public float BaseSpirit;

		public float BasePoison;

		public float BaseArmor;

		public float BaseBlockPower;

		private static readonly CultureInfo Inv = CultureInfo.InvariantCulture;

		public int FilledSlots => InsertedScrollIds.FindAll((string s) => !string.IsNullOrEmpty(s)).Count;

		public int EmptySlots => SlotCount - FilledSlots;

		public bool HasFreeSlot => EmptySlots > 0;

		public bool HasBaseDamages => BasePierce > 0f || BaseBlunt > 0f || BaseSlash > 0f || BaseFire > 0f || BaseFrost > 0f || BaseLightning > 0f || BaseSpirit > 0f || BasePoison > 0f;

		public RarityItemData()
		{
		}

		public RarityItemData(ItemRarity rarity)
		{
			Rarity = rarity;
			SlotCount = RarityData.Info[rarity].SlotCount;
			InsertedScrollIds = new List<string>();
			for (int i = 0; i < SlotCount; i++)
			{
				InsertedScrollIds.Add(string.Empty);
			}
		}

		public void SaveBaseDamages(ItemData item)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			DamageTypes damages = item.m_shared.m_damages;
			BasePierce = damages.m_pierce;
			BaseBlunt = damages.m_blunt;
			BaseSlash = damages.m_slash;
			BaseFire = damages.m_fire;
			BaseFrost = damages.m_frost;
			BaseLightning = damages.m_lightning;
			BaseSpirit = damages.m_spirit;
			BasePoison = damages.m_poison;
			BaseArmor = item.m_shared.m_armor;
			BaseBlockPower = item.m_shared.m_blockPower;
			Logger.LogInfo((object)($"[SaveBase] {item.m_shared.m_name} q={item.m_quality} " + $"BaseArmor={BaseArmor:0.##} BaseBlockPower={BaseBlockPower:0.##}"));
		}

		public void RestoreBaseDamages(ItemData item)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			DamageTypes damages = item.m_shared.m_damages;
			damages.m_pierce = BasePierce;
			damages.m_blunt = BaseBlunt;
			damages.m_slash = BaseSlash;
			damages.m_fire = BaseFire;
			damages.m_frost = BaseFrost;
			damages.m_lightning = BaseLightning;
			damages.m_spirit = BaseSpirit;
			damages.m_poison = BasePoison;
			item.m_shared.m_damages = damages;
		}

		public bool InsertScroll(string scrollPerkId)
		{
			for (int i = 0; i < InsertedScrollIds.Count; i++)
			{
				if (string.IsNullOrEmpty(InsertedScrollIds[i]))
				{
					InsertedScrollIds[i] = scrollPerkId;
					return true;
				}
			}
			return false;
		}

		public string RemoveScroll(int slotIndex)
		{
			if (slotIndex < 0 || slotIndex >= InsertedScrollIds.Count)
			{
				return string.Empty;
			}
			string result = InsertedScrollIds[slotIndex];
			InsertedScrollIds[slotIndex] = string.Empty;
			return result;
		}

		public string Serialize()
		{
			string text = string.Join(",", InsertedScrollIds);
			string text2 = string.Join(";", BasePierce.ToString("F4", Inv), BaseBlunt.ToString("F4", Inv), BaseSlash.ToString("F4", Inv), BaseFire.ToString("F4", Inv), BaseFrost.ToString("F4", Inv), BaseLightning.ToString("F4", Inv), BaseSpirit.ToString("F4", Inv), BasePoison.ToString("F4", Inv), BaseArmor.ToString("F4", Inv), BaseBlockPower.ToString("F4", Inv));
			return $"{(int)Rarity}|{SlotCount}|{text}|{text2}";
		}

		public static RarityItemData Deserialize(string raw)
		{
			if (string.IsNullOrEmpty(raw))
			{
				return null;
			}
			string[] array = raw.Split(new char[1] { '|' });
			if (array.Length < 1)
			{
				return null;
			}
			RarityItemData rarityItemData = new RarityItemData();
			if (int.TryParse(array[0], out var result))
			{
				rarityItemData.Rarity = (ItemRarity)result;
			}
			if (array.Length > 1 && int.TryParse(array[1], out var result2))
			{
				rarityItemData.SlotCount = result2;
			}
			else
			{
				rarityItemData.SlotCount = RarityData.Info[rarityItemData.Rarity].SlotCount;
			}
			rarityItemData.InsertedScrollIds = new List<string>();
			if (array.Length > 2 && !string.IsNullOrEmpty(array[2]))
			{
				string[] array2 = array[2].Split(new char[1] { ',' });
				foreach (string item in array2)
				{
					rarityItemData.InsertedScrollIds.Add(item);
				}
			}
			while (rarityItemData.InsertedScrollIds.Count < rarityItemData.SlotCount)
			{
				rarityItemData.InsertedScrollIds.Add(string.Empty);
			}
			string[] d;
			if (array.Length > 3 && !string.IsNullOrEmpty(array[3]))
			{
				d = array[3].Split(new char[1] { ';' });
				rarityItemData.BasePierce = F(0);
				rarityItemData.BaseBlunt = F(1);
				rarityItemData.BaseSlash = F(2);
				rarityItemData.BaseFire = F(3);
				rarityItemData.BaseFrost = F(4);
				rarityItemData.BaseLightning = F(5);
				rarityItemData.BaseSpirit = F(6);
				rarityItemData.BasePoison = F(7);
				rarityItemData.BaseArmor = F(8);
				rarityItemData.BaseBlockPower = F(9);
			}
			return rarityItemData;
			float F(int i)
			{
				float result3;
				return (d.Length > i && float.TryParse(d[i], NumberStyles.Float, Inv, out result3)) ? result3 : 0f;
			}
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "RemoveObjects")]
	public static class ZNetScene_RemoveObjects_NullSafePatch
	{
		[HarmonyPrefix]
		public static void Prefix(ZNetScene __instance)
		{
			List<ZDO> list = new List<ZDO>();
			foreach (KeyValuePair<ZDO, ZNetView> instance in __instance.m_instances)
			{
				if ((Object)(object)instance.Value == (Object)null || (Object)(object)((Component)instance.Value).gameObject == (Object)null)
				{
					list.Add(instance.Key);
				}
			}
			foreach (ZDO item in list)
			{
				__instance.m_instances.Remove(item);
			}
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Shutdown")]
	public static class ZNetScene_Shutdown_NullSafePatch
	{
		[HarmonyPrefix]
		public static void Prefix(ZNetScene __instance)
		{
			List<ZDO> list = new List<ZDO>();
			foreach (KeyValuePair<ZDO, ZNetView> instance in __instance.m_instances)
			{
				if ((Object)(object)instance.Value == (Object)null || (Object)(object)((Component)instance.Value).gameObject == (Object)null)
				{
					list.Add(instance.Key);
				}
			}
			foreach (ZDO item in list)
			{
				__instance.m_instances.Remove(item);
			}
		}
	}
	[HarmonyPatch]
	public static class RarityItemVFX
	{
		[CompilerGenerated]
		private sealed class <ApplyVFXNextFrame>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ItemDrop drop;

			private float <timeout>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)drop == (Object)null || (Object)(object)((Component)drop).gameObject == (Object)null)
					{
						return false;
					}
					<timeout>5__1 = 5f;
					goto IL_00b4;
				case 2:
					<>1__state = -1;
					<timeout>5__1 -= 0.2f;
					goto IL_00b4;
				case 3:
					{
						<>1__state = -1;
						if ((Object)(object)drop == (Object)null || (Object)(object)((Component)drop).gameObject == (Object)null)
						{
							return false;
						}
						ApplyVFX(drop);
						return false;
					}
					IL_00b4:
					if (<timeout>5__1 > 0f && ((Object)(object)Player.m_localPlayer == (Object)null || ((Character)Player.m_localPlayer).IsTeleporting()))
					{
						<>2__current = (object)new WaitForSeconds(0.2f);
						<>1__state = 2;
						return true;
					}
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
			}

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

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

		private const string VFX_CHILD_NAME = "RarityVFX";

		[HarmonyPatch(typeof(ItemDrop), "Start")]
		[HarmonyPostfix]
		public static void ItemDrop_Start_Postfix(ItemDrop __instance)
		{
			((MonoBehaviour)__instance).StartCoroutine(ApplyVFXNextFrame(__instance));
		}

		[IteratorStateMachine(typeof(<ApplyVFXNextFrame>d__2))]
		private static IEnumerator ApplyVFXNextFrame(ItemDrop drop)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyVFXNextFrame>d__2(0)
			{
				drop = drop
			};
		}

		public static void ApplyVFX(ItemDrop drop)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Expected O, but got Unknown
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)drop == (Object)null)
			{
				return;
			}
			ItemData itemData = drop.m_itemData;
			if (itemData == null)
			{
				return;
			}
			Color color;
			if (ScrollItem.IsEnchantScroll(itemData))
			{
				ScrollItem.TryGetScrollTier(itemData, out var rarity);
				if (rarity == ItemRarity.Common)
				{
					return;
				}
				color = RarityData.Info[rarity].Color;
			}
			else
			{
				if (!RarityPatches.IsWeaponOrArmor(itemData))
				{
					return;
				}
				RarityItemData rarityItemData = RarityTooltip.Get(itemData);
				if (rarityItemData == null || rarityItemData.Rarity == ItemRarity.Common)
				{
					return;
				}
				color = RarityData.Info[rarityItemData.Rarity].Color;
			}
			Transform val = FindDeep(((Component)drop).transform, "fx_ItemSparkles");
			if ((Object)(object)val == (Object)null)
			{
				Logger.LogWarning((object)("[Rarity VFX] No se encontró fx_ItemSparkles en " + ((Object)drop).name));
				return;
			}
			ParticleSystem[] componentsInChildren = ((Component)val).GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val2 in componentsInChildren)
			{
				MainModule main = val2.main;
				((MainModule)(ref main)).startColor = new MinMaxGradient(new Color(color.r, color.g, color.b, 1f), new Color(color.r, color.g, color.b, 0.4f));
				((MainModule)(ref main)).maxParticles = 100;
				((MainModule)(ref main)).simulationSpeed = 1f;
				EmissionModule emission = val2.emission;
				((EmissionModule)(ref emission)).rateOverTime = MinMaxCurve.op_Implicit(50f);
				ColorOverLifetimeModule colorOverLifetime = val2.colorOverLifetime;
				if (((ColorOverLifetimeModule)(ref colorOverLifetime)).enabled)
				{
					Gradient val3 = new Gradient();
					val3.SetKeys((GradientColorKey[])(object)new GradientColorKey[2]
					{
						new GradientColorKey(color, 0f),
						new GradientColorKey(color, 1f)
					}, (GradientAlphaKey[])(object)new GradientAlphaKey[2]
					{
						new GradientAlphaKey(1f, 0f),
						new GradientAlphaKey(0f, 1f)
					});
					((ColorOverLifetimeModule)(ref colorOverLifetime)).color = new MinMaxGradient(val3);
				}
				ParticleSystemRenderer component = ((Component)val2).GetComponent<ParticleSystemRenderer>();
				if ((Object)(object)component != (Object)null && (Object)(object)((Renderer)component).material != (Object)null)
				{
					Material val4 = new Material(((Renderer)component).material);
					if (val4.HasProperty("_Color"))
					{
						val4.SetColor("_Color", color);
					}
					if (val4.HasProperty("_TintColor"))
					{
						val4.SetColor("_TintColor", color);
					}
					if (val4.HasProperty("_EmissionColor"))
					{
						val4.SetColor("_EmissionColor", color * 2f);
					}
					((Renderer)component).material = val4;
				}
			}
			val.localScale = new Vector3(1f, 4f, 1f);
			Logger.LogInfo((object)("[Rarity VFX] " + ((Object)drop).name + " recoloreado | color #" + ColorUtility.ToHtmlStringRGB(color)));
		}

		private static Transform FindDeep(Transform parent, string name)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			foreach (Transform item in parent)
			{
				Transform val = item;
				if (((Object)val).name == name)
				{
					return val;
				}
				Transform val2 = FindDeep(val, name);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			return null;
		}
	}
	[HarmonyPatch]
	public static class RarityPatches
	{
		private static bool _addItemProcessing;

		[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
		[HarmonyPostfix]
		public static void DoCrafting_Postfix(InventoryGui __instance, Player player)
		{
			Inventory inventory = ((Humanoid)player).GetInventory();
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (!allItem.m_customData.ContainsKey("RarityData") && IsWeaponOrArmor(allItem) && allItem.m_quality <= 1)
				{
					RarityItemData orCreate = RarityTooltip.GetOrCreate(allItem);
					orCreate.SaveBaseDamages(allItem);
					ApplyStatBonusToDamages(allItem, orCreate);
					ApplyStatBonusToArmor(allItem, orCreate);
					ApplyStatBonusToBlockPower(allItem, orCreate);
					RarityTooltip.Save(allItem, orCreate);
				}
			}
		}

		[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
		{
			typeof(string),
			typeof(int),
			typeof(int),
			typeof(int),
			typeof(long),
			typeof(string),
			typeof(Vector2i),
			typeof(bool)
		})]
		[HarmonyPostfix]
		public static void AddItem_Postfix(ref ItemData __result)
		{
			//IL_01e1: 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_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			if (__result == null || !IsWeaponOrArmor(__result))
			{
				return;
			}
			RarityItemData rarityItemData = RarityTooltip.Get(__result);
			if (rarityItemData == null || __result.m_quality <= 1 || _addItemProcessing)
			{
				return;
			}
			_addItemProcessing = true;
			try
			{
				ObjectDB instance = ObjectDB.instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					GameObject dropPrefab = __result.m_dropPrefab;
					obj = instance.GetItemPrefab(((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? "");
				}
				GameObject val = (GameObject)obj;
				ItemData val2 = ((val == null) ? null : val.GetComponent<ItemDrop>()?.m_itemData);
				if (val2 == null && (Object)(object)ObjectDB.instance != (Object)null)
				{
					foreach (GameObject item in ObjectDB.instance.m_items)
					{
						ItemDrop val3 = ((item != null) ? item.GetComponent<ItemDrop>() : null);
						if (val3?.m_itemData?.m_shared?.m_name == __result.m_shared.m_name)
						{
							val2 = val3.m_itemData;
							break;
						}
					}
				}
				if (val2 != null)
				{
					float baseArmor = val2.m_shared.m_armor + val2.m_shared.m_armorPerLevel * (float)(__result.m_quality - 1);
					rarityItemData.BaseArmor = baseArmor;
					float num = val2.m_shared.m_blockPower + val2.m_shared.m_blockPowerPerLevel * (float)(__result.m_quality - 1);
					if (num > 0f)
					{
						rarityItemData.BaseBlockPower = num;
					}
					DamageTypes damages = val2.m_shared.m_damages;
					DamageTypes damagesPerLevel = val2.m_shared.m_damagesPerLevel;
					if (damages.m_pierce > 0f)
					{
						rarityItemData.BasePierce = damages.m_pierce + damagesPerLevel.m_pierce * (float)(__result.m_quality - 1);
					}
					if (damages.m_blunt > 0f)
					{
						rarityItemData.BaseBlunt = damages.m_blunt + damagesPerLevel.m_blunt * (float)(__result.m_quality - 1);
					}
					if (damages.m_slash > 0f)
					{
						rarityItemData.BaseSlash = damages.m_slash + damagesPerLevel.m_slash * (float)(__result.m_quality - 1);
					}
					if (damages.m_fire > 0f)
					{
						rarityItemData.BaseFire = damages.m_fire + damagesPerLevel.m_fire * (float)(__result.m_quality - 1);
					}
					if (damages.m_frost > 0f)
					{
						rarityItemData.BaseFrost = damages.m_frost + damagesPerLevel.m_frost * (float)(__result.m_quality - 1);
					}
					if (damages.m_lightning > 0f)
					{
						rarityItemData.BaseLightning = damages.m_lightning + damagesPerLevel.m_lightning * (float)(__result.m_quality - 1);
					}
					if (damages.m_spirit > 0f)
					{
						rarityItemData.BaseSpirit = damages.m_spirit + damagesPerLevel.m_spirit * (float)(__result.m_quality - 1);
					}
					if (damages.m_poison > 0f)
					{
						rarityItemData.BasePoison = damages.m_poison + damagesPerLevel.m_poison * (float)(__result.m_quality - 1);
					}
				}
				else
				{
					float num2 = 1f + RarityData.Info[rarityItemData.Rarity].StatBonus;
					float num3 = rarityItemData.BaseArmor * num2;
					bool flag = Mathf.Abs(__result.m_shared.m_armor - num3) < 0.2f;
					if (rarityItemData.BaseArmor > 0f && flag)
					{
						rarityItemData.BaseArmor = __result.m_shared.m_armor / num2;
					}
					else if (rarityItemData.BaseArmor <= 0f)
					{
						rarityItemData.SaveBaseDamages(__result);
					}
					float num4 = rarityItemData.BaseBlockPower * num2;
					bool flag2 = Mathf.Abs(__result.m_shared.m_blockPower - num4) < 0.2f;
					if (rarityItemData.BaseBlockPower > 0f && flag2)
					{
						rarityItemData.BaseBlockPower = __result.m_shared.m_blockPower / num2;
					}
				}
				ApplyStatBonusToDamages(__result, rarityItemData);
				ApplyStatBonusToArmor(__result, rarityItemData);
				ApplyStatBonusToBlockPower(__result, rarityItemData);
				EnchantBonusManager.RefreshSingleItem(__result);
				RarityTooltip.Save(__result, rarityItemData);
			}
			finally
			{
				_addItemProcessing = false;
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
		[HarmonyPostfix]
		public static void UpdateGui_Postfix(InventoryGrid __instance)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			Inventory inventory = __instance.m_inventory;
			if (inventory == null)
			{
				return;
			}
			foreach (Element element in __instance.m_elements)
			{
				if (!element.m_used)
				{
					((Graphic)element.m_icon).color = Color.white;
					continue;
				}
				ItemData itemAt = inventory.GetItemAt(element.m_pos.x, element.m_pos.y);
				if (itemAt == null)
				{
					((Graphic)element.m_icon).color = Color.white;
					continue;
				}
				if (ScrollItem.IsEnchantScroll(itemAt))
				{
					ScrollItem.TryGetScrollTier(itemAt, out var rarity);
					Color color = RarityData.Info[rarity].Color;
					((Graphic)element.m_icon).color = Color.Lerp(Color.white, color, 0.45f);
					string text = ColorUtility.ToHtmlStringRGB(color);
					element.m_tooltip.m_topic = "<color=#" + text + ">" + itemAt.m_shared.m_name + "</color>";
					continue;
				}
				RarityItemData rarityItemData = RarityTooltip.Get(itemAt);
				if (rarityItemData == null || rarityItemData.Rarity == ItemRarity.Common)
				{
					((Graphic)element.m_icon).color = Color.white;
					element.m_tooltip.m_topic = itemAt.m_shared.m_name;
					continue;
				}
				Color color2 = RarityData.Info[rarityItemData.Rarity].Color;
				((Graphic)element.m_icon).color = Color.Lerp(Color.white, color2, 0.35f);
				string text2 = ColorUtility.ToHtmlStringRGB(color2);
				element.m_tooltip.m_topic = "<color=#" + text2 + ">" + itemAt.m_shared.m_name + "</color>";
			}
		}

		public static bool IsWeaponOrArmor(ItemData item)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			ItemType itemType = item.m_shared.m_itemType;
			return (int)itemType == 3 || (int)itemType == 14 || (int)itemType == 4 || (int)itemType == 5 || (int)itemType == 6 || (int)itemType == 7 || (int)itemType == 11 || (int)itemType == 17 || (int)itemType == 18;
		}

		public static void ApplyStatBonusToDamages(ItemData item, RarityItemData data)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			if (data.Rarity != 0 && data.HasBaseDamages)
			{
				float num = 1f + RarityData.Info[data.Rarity].StatBonus;
				DamageTypes damages = item.m_shared.m_damages;
				DamageTypes damagesPerLevel = item.m_shared.m_damagesPerLevel;
				float num2 = item.m_quality - 1;
				if (data.BasePierce > 0f)
				{
					damages.m_pierce = data.BasePierce * num - damagesPerLevel.m_pierce * num2;
				}
				if (data.BaseBlunt > 0f)
				{
					damages.m_blunt = data.BaseBlunt * num - damagesPerLevel.m_blunt * num2;
				}
				if (data.BaseSlash > 0f)
				{
					damages.m_slash = data.BaseSlash * num - damagesPerLevel.m_slash * num2;
				}
				if (data.BaseFire > 0f)
				{
					damages.m_fire = data.BaseFire * num - damagesPerLevel.m_fire * num2;
				}
				if (data.BaseFrost > 0f)
				{
					damages.m_frost = data.BaseFrost * num - damagesPerLevel.m_frost * num2;
				}
				if (data.BaseLightning > 0f)
				{
					damages.m_lightning = data.BaseLightning * num - damagesPerLevel.m_lightning * num2;
				}
				if (data.BaseSpirit > 0f)
				{
					damages.m_spirit = data.BaseSpirit * num - damagesPerLevel.m_spirit * num2;
				}
				if (data.BasePoison > 0f)
				{
					damages.m_poison = data.BasePoison * num - damagesPerLevel.m_poison * num2;
				}
				item.m_shared.m_damages = damages;
			}
		}

		public static void ApplyStatBonusToArmor(ItemData item, RarityItemData data)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Invalid comparison between Unknown and I4
			if (data.Rarity != 0 && !(data.BaseArmor <= 0f))
			{
				ItemType itemType = item.m_shared.m_itemType;
				if ((int)itemType == 6 || (int)itemType == 7 || (int)itemType == 11 || (int)itemType == 17)
				{
					float num = 1f + RarityData.Info[data.Rarity].StatBonus;
					float num2 = item.m_shared.m_armorPerLevel * (float)(item.m_quality - 1);
					item.m_shared.m_armor = data.BaseArmor * num - num2;
				}
			}
		}

		public static void ApplyStatBonusToBlockPower(ItemData item, RarityItemData data)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			if (data.Rarity != 0 && !(data.BaseBlockPower <= 0f) && (int)item.m_shared.m_itemType == 5)
			{
				float num = 1f + RarityData.Info[data.Rarity].StatBonus;
				float num2 = item.m_shared.m_blockPowerPerLevel * (float)(item.m_quality - 1);
				item.m_shared.m_blockPower = data.BaseBlockPower * num - num2;
			}
		}
	}
	[HarmonyPatch]
	public static class GetTooltip_Patch
	{
		private static MethodBase TargetMethod()
		{
			return typeof(ItemData).GetMethod("GetTooltip", BindingFlags.Static | BindingFlags.Public, null, new Type[5]
			{
				typeof(ItemData),
				typeof(int),
				typeof(bool),
				typeof(float),
				typeof(int)
			}, null);
		}

		[HarmonyPostfix]
		public static void Postfix(ItemData item, ref string __result)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (item == null)
			{
				return;
			}
			if (ScrollItem.IsEnchantScroll(item))
			{
				ScrollItem.TryGetScrollTier(item, out var rarity);
				RarityInfo rarityInfo = RarityData.Info[rarity];
				string text = ColorUtility.ToHtmlStringRGB(rarityInfo.Color);
				string text2 = "";
				if (item.m_customData.TryGetValue("ScrollPerk", out var value) && !string.IsNullOrEmpty(value))
				{
					string[] array = value.Split(new char[1] { ':' });
					ScrollPerkDef byName = ScrollPerkRegistry.GetByName(array[0]);
					if (byName != null)
					{
						string text3 = ((array.Length == 2) ? (byName.GetDisplayText(rarity) + " vs " + array[1]) : byName.GetDisplayText(rarity));
						text2 = "\n<color=#" + text + ">" + text3 + "</color>";
					}
				}
				__result = "<color=#" + text + "><b>Pergamino " + rarityInfo.Name + "</b></color>" + text2 + "\n" + (ScrollItem.IsRevealed(item) ? "Click derecho para encantar" : "Click derecho para desbloquear") + ".\n\n<color=#" + text + ">Rareza: " + rarityInfo.Name + "</color>";
				return;
			}
			RarityItemData rarityItemData = RarityTooltip.Get(item);
			if (rarityItemData == null || rarityItemData.Rarity == ItemRarity.Common)
			{
				return;
			}
			string value2 = "Tier: " + RarityData.Info[rarityItemData.Rarity].Name;
			if (__result == null || !__result.Contains(value2))
			{
				__result = RarityTooltip.ColorizeHeader(__result, rarityItemData);
				__result = RarityTooltip.ReplaceDamageLines(__result, rarityItemData, item);
				__result = RarityTooltip.ReplaceArmorLine(__result, rarityItemData, item);
				__result = RarityTooltip.ReplaceBlockPowerLine(__result, rarityItemData, item);
				string text4 = RarityTooltip.BuildTooltipAddition(rarityItemData, item);
				if (!string.IsNullOrEmpty(text4))
				{
					__result = __result + "\n" + text4;
				}
			}
		}
	}
	[BepInPlugin("com.tuusuario.valheim.rarity", "ItemRaritySystem", "0.2.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class RarityPlugin : BaseUnityPlugin
	{
		public const string ModGUID = "com.tuusuario.valheim.rarity";

		public const string ModName = "ItemRaritySystem";

		public const string ModVersion = "0.2.0";

		private Harmony _harmony;

		private void Awake()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			Logger.LogInfo((object)"[ItemRaritySystem] Cargando sistema de rareza v0.2.0...");
			_harmony = new Harmony("com.tuusuario.valheim.rarity");
			_harmony.PatchAll();
			ScrollItem.Register();
			GUIManager.OnCustomGUIAvailable += CreateScrollUI;
			Logger.LogInfo((object)"[ItemRaritySystem] ¡Listo! Patches aplicados.");
		}

		private void CreateScrollUI()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!((Object)(object)ScrollEnchantUI.Instance != (Object)null))
			{
				GameObject val = new GameObject("ScrollEnchantUI");
				Object.DontDestroyOnLoad((Object)(object)val);
				val.AddComponent<ScrollEnchantUI>();
			}
		}

		private void OnDestroy()
		{
			GUIManager.OnCustomGUIAvailable -= CreateScrollUI;
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class RarityTooltip
	{
		private const string CUSTOM_DATA_KEY = "RarityData";

		private const string SMITH_LEVEL_KEY = "nazhi_blacksmith_lvl";

		private const float SMITH_DAMAGE_ARMOR_MAX_100 = 1f;

		private static readonly Dictionary<ItemRarity, string> SlotFilledChar = new Dictionary<ItemRarity, string>
		{
			{
				ItemRarity.Common,
				"\ud83d\udc8e"
			},
			{
				ItemRarity.Uncommon,
				"\ud83d\udc8e"
			},
			{
				ItemRarity.Rare,
				"\ud83d\udc8e"
			},
			{
				ItemRarity.Epic,
				"\ud83d\udc8e"
			},
			{
				ItemRarity.Legendary,
				"\ud83d\udc8e"
			}
		};

		private const string SLOT_EMPTY = "\ud83d\udd28";

		private const string SEP = "━━━━━━━━━━━━━━━━";

		private static readonly string[] ItemTypeKeys = new string[14]
		{
			"$item_onehanded", "$item_twohanded", "$item_bow", "$item_shield", "$item_helmet", "$item_chest", "$item_legs", "$item_shoulder", "$item_utility", "$item_tool",
			"$item_ammo", "$item_trophy", "$item_consumable", "$item_material"
		};

		public static string ColorizeHeader(string tooltip, RarityItemData data)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(tooltip) || data == null || data.Rarity == ItemRarity.Common)
			{
				return tooltip;
			}
			RarityInfo rarityInfo = RarityData.Info[data.Rarity];
			string text = ColorUtility.ToHtmlStringRGB(rarityInfo.Color);
			string text2 = null;
			string[] itemTypeKeys = ItemTypeKeys;
			foreach (string text3 in itemTypeKeys)
			{
				if (tooltip.Contains(text3))
				{
					text2 = text3;
					break;
				}
			}
			if (text2 == null)
			{
				return tooltip;
			}
			int num = tooltip.IndexOf(text2, StringComparison.OrdinalIgnoreCase);
			if (num < 0)
			{
				return tooltip;
			}
			string text4 = tooltip.Substring(0, num).TrimEnd('\n', '\r');
			string text5 = tooltip.Substring(num);
			string[] array = text4.Split(new char[1] { '\n' });
			StringBuilder stringBuilder = new StringBuilder();
			string[] array2 = array;
			foreach (string text6 in array2)
			{
				string text7 = text6.TrimEnd(new char[1] { '\r' });
				if (string.IsNullOrWhiteSpace(text7))
				{
					stringBuilder.AppendLine();
					continue;
				}
				stringBuilder.AppendLine("<color=#" + text + ">" + text7 + "</color>");
			}
			stringBuilder.AppendLine("<color=#" + text + ">Tier: " + rarityInfo.Name + "</color>");
			stringBuilder.AppendLine("<color=#" + text + ">━━━━━━━━━━━━━━━━</color>");
			return stringBuilder.ToString() + text5;
		}

		public static string ReplaceDamageLines(string tooltip, RarityItemData data, ItemData item)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_00aa: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(tooltip) || item == null)
			{
				return tooltip;
			}
			RarityInfo rarityInfo = RarityData.Info[data.Rarity];
			string arg = ColorUtility.ToHtmlStringRGB(rarityInfo.Color);
			float smithFactor = GetSmithFactor(GetSmithLevel(item));
			DamageTypes damage = item.GetDamage(item.m_quality, (float)item.m_worldLevel);
			Dictionary<string, (float, float, string)> dictionary = new Dictionary<string, (float, float, string)>
			{
				{
					"pierce",
					(damage.m_pierce, data.BasePierce, "Perforante")
				},
				{
					"blunt",
					(damage.m_blunt, data.BaseBlunt, "Contundente")
				},
				{
					"slash",
					(damage.m_slash, data.BaseSlash, "Cortante")
				},
				{
					"fire",
					(damage.m_fire, data.BaseFire, "Fuego")
				},
				{
					"frost",
					(damage.m_frost, data.BaseFrost, "Escarcha")
				},
				{
					"lightning",
					(damage.m_lightning, data.BaseLightning, "Rayo")
				},
				{
					"spirit",
					(damage.m_spirit, data.BaseSpirit, "Espíritu")
				},
				{
					"poison",
					(damage.m_poison, data.BasePoison, "Veneno")
				}
			};
			foreach (KeyValuePair<string, (float, float, string)> item2 in dictionary)
			{
				string pattern = "^\\$inventory_" + item2.Key + "\\s*:.*$";
				var (num, num2, arg2) = item2.Value;
				if (num <= 0f)
				{
					tooltip = Regex.Replace(tooltip, pattern, string.Empty, RegexOptions.IgnoreCase | RegexOptions.Multiline);
					continue;
				}
				float num3 = num;
				float vanillaBase = num2 * smithFactor;
				string text = ((num2 > 0f) ? FormatStatDiff(num3, vanillaBase) : string.Empty);
				string replacement = $"<color=#{arg}>{arg2}: {num3:0.#}" + ((text.Length > 0) ? ("  " + text) : string.Empty) + "</color>";
				tooltip = Regex.Replace(tooltip, pattern, replacement, RegexOptions.IgnoreCase | RegexOptions.Multiline);
			}
			return tooltip;
		}

		public static string ReplaceBlockPowerLine(string tooltip, RarityItemData data, ItemData item)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(tooltip) || item == null)
			{
				return tooltip;
			}
			if ((int)item.m_shared.m_itemType != 5)
			{
				return tooltip;
			}
			RarityInfo rarityInfo = RarityData.Info[data.Rarity];
			string arg = ColorUtility.ToHtmlStringRGB(rarityInfo.Color);
			float num = item.m_shared.m_blockPowerPerLevel * (float)(item.m_quality - 1);
			float num2 = item.m_shared.m_blockPower + num;
			string text = ((data.BaseBlockPower > 0f) ? FormatStatDiff(num2, data.BaseBlockPower) : string.Empty);
			string replacement = $"<color=#{arg}>$item_blockarmor: <color=orange>{num2:0.#}</color>" + ((text.Length > 0) ? ("  " + text) : string.Empty) + "</color>";
			tooltip = Regex.Replace(tooltip, "^\\$item_blockarmor\\s*:.*$", replacement, RegexOptions.IgnoreCase | RegexOptions.Multiline);
			return tooltip;
		}

		public static string ReplaceArmorLine(string tooltip, RarityItemData data, ItemData item)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			if (string.IsNullOrEmpty(tooltip) || item == null)
			{
				return tooltip;
			}
			if ((int)item.m_shared.m_itemType != 6 && (int)item.m_shared.m_itemType != 7 && (int)item.m_shared.m_itemType != 11 && (int)item.m_shared.m_itemType != 17)
			{
				return tooltip;
			}
			RarityInfo rarityInfo = RarityData.Info[data.Rarity];
			string arg = ColorUtility.ToHtmlStringRGB(rarityInfo.Color);
			float smithFactor = GetSmithFactor(GetSmithLevel(item));
			float num = 0f;
			foreach (string insertedScrollId in data.InsertedScrollIds)
			{
				if (!string.IsNullOrEmpty(insertedScrollId))
				{
					ScrollPerkDef byName = ScrollPerkRegistry.GetByName(insertedScrollId.Split(new char[1] { ':' })[0]);
					if (byName != null && byName.Type == ScrollPerkType.Armadura)
					{
						num += byName.GetValue(data.Rarity);
					}
				}
			}
			float num2 = data.BaseArmor * (1f + rarityInfo.StatBonus);
			float num3 = num2 * smithFactor;
			float num4 = num3 + num;
			string text = ((data.BaseArmor > 0f) ? FormatStatDiff(num4, data.BaseArmor) : string.Empty);
			Logger.LogInfo((object)($"[ArmorDebug] base={data.BaseArmor:0.##} " + $"afterRarity={num2:0.##} " + $"afterSmith={num3:0.##} " + $"perk={num:0.##} " + $"total={num4:0.##}"));
			string replacement = $"<color=#{arg}>Armadura: {num4:0.#}" + ((text.Length > 0) ? ("  " + text) : string.Empty) + "</color>";
			tooltip = Regex.Replace(tooltip, "^\\$item_armor\\s*:.*$", replacement, RegexOptions.IgnoreCase | RegexOptions.Multiline);
			return tooltip;
		}

		public static string BuildTooltipAddition(RarityItemData data, ItemData item = null)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (data == null || data.Rarity == ItemRarity.Common)
			{
				return string.Empty;
			}
			RarityInfo rarityInfo = RarityData.Info[data.Rarity];
			string text = ColorUtility.ToHtmlStringRGB(rarityInfo.Color);
			string filledChar = SlotFilledChar[data.Rarity];
			StringBuilder stringBuilder = new StringBuilder();
			if (data.SlotCount > 0)
			{
				stringBuilder.AppendLine();
				for (int i = 0; i < data.SlotCount; i++)
				{
					string text2 = ((i < data.InsertedScrollIds.Count) ? data.InsertedScrollIds[i] : string.Empty);
					if (string.IsNullOrEmpty(text2))
					{
						stringBuilder.AppendLine("\ud83d\udd28 <color=#888888>Slot vacío</color>");
					}
					else
					{
						stringBuilder.AppendLine(BuildPerkDescription(text2, data.Rarity, text, filledChar));
					}
				}
			}
			stringBuilder.AppendLine();
			stringBuilder.Append("<color=#" + text + ">━━━━━━━━━━━━━━━━</color>");
			return stringBuilder.ToString();
		}

		public static RarityItemData GetOrCreate(ItemData itemData)
		{
			if (itemData.m_customData.TryGetValue("RarityData", out var value))
			{
				RarityItemData rarityItemData = RarityItemData.Deserialize(value);
				if (rarityItemData != null)
				{
					return rarityItemData;
				}
			}
			ItemRarity rarity = RarityData.RollRarity();
			RarityItemData rarityItemData2 = new RarityItemData(rarity);
			itemData.m_customData["RarityData"] = rarityItemData2.Serialize();
			return rarityItemData2;
		}

		public static RarityItemData Get(ItemData itemData)
		{
			if (itemData.m_customData.TryGetValue("RarityData", out var value))
			{
				return RarityItemData.Deserialize(value);
			}
			return null;
		}

		public static void Save(ItemData itemData, RarityItemData data)
		{
			itemData.m_customData["RarityData"] = data.Serialize();
		}

		public static string GetRarityHex(RarityItemData data)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (data == null)
			{
				return "ffffff";
			}
			return ColorUtility.ToHtmlStringRGB(RarityData.Info[data.Rarity].Color);
		}

		private static int GetSmithLevel(ItemData item)
		{
			if (item?.m_customData == null)
			{
				return 0;
			}
			if (!item.m_customData.TryGetValue("nazhi_blacksmith_lvl", out var value))
			{
				return 0;
			}
			int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result);
			return result;
		}

		private static float GetSmithFactor(int smithLvl)
		{
			if (smithLvl <= 0)
			{
				return 1f;
			}
			return 1f + 1f * Mathf.Clamp01((float)smithLvl / 100f);
		}

		private static string FormatStatDiff(float current, float vanillaBase)
		{
			if (vanillaBase <= 0f)
			{
				return string.Empty;
			}
			float num = current - vanillaBase;
			float num2 = num / vanillaBase * 100f;
			if (Mathf.Abs(num) < 0.05f)
			{
				return string.Empty;
			}
			bool flag = num >= 0f;
			string text = (flag ? "↑" : "↓");
			string text2 = (flag ? "00e676" : "ff5252");
			string arg = (flag ? "+" : "");
			string text3 = $"{arg}{num:0.#}";
			string text4 = $"{arg}{num2:0.#}%";
			return "<color=#" + text2 + ">" + text + " " + text3 + " (" + text4 + ")</color>";
		}

		private static string BuildPerkDescription(string scrollId, ItemRarity rarity, string hex, string filledChar)
		{
			string[] array = scrollId.Split(new char[1] { ':' });
			string displayName = array[0];
			string text = ((array.Length == 2) ? array[1] : null);
			ScrollPerkDef byName = ScrollPerkRegistry.GetByName(displayName);
			if (byName == null)
			{
				return filledChar + " <color=#" + hex + ">" + scrollId + "</color>";
			}
			float value = byName.GetValue(rarity);
			string text2 = ((byName.Type == ScrollPerkType.Vida || byName.Type == ScrollPerkType.Armadura || byName.Type == ScrollPerkType.Durabilidad || byName.Type == ScrollPerkType.WeapSkill || byName.Type == ScrollPerkType.Weight) ? $"{value:0}" : $"{value:0.##}%");
			if (byName.Type == ScrollPerkType.NoMovPen)
			{
				text2 = "";
			}
			ScrollPerkType type = byName.Type;
			if (1 == 0)
			{
			}
			string text3 = type switch
			{
				ScrollPerkType.Pierce => "Perforante: Aumenta en +" + text2 + " el daño perforante", 
				ScrollPerkType.Blunt => "Contundente: Aumenta en +" + text2 + " el daño contundente", 
				ScrollPerkType.Slash => "Cortante: Aumenta en +" + text2 + " el daño cortante", 
				ScrollPerkType.DmgMagico => "Dominio Elemental: Aumenta en +" + text2 + " el daño mágico", 
				ScrollPerkType.VelocidadAtk => "Frenesí: Aumenta en +" + text2 + " la velocidad de ataque", 
				ScrollPerkType.DmgFaccion => "Oportunista: Aumenta en +" + text2 + " el daño vs " + TranslateFaction(text ?? "enemigos"), 
				ScrollPerkType.ReduccionDmg => "Piel de Hierro: Reduce en " + text2 + " el daño recibido", 
				ScrollPerkType.Armadura => "Bastión: Aumenta en +" + text2 + " la armadura", 
				ScrollPerkType.Vida => "Vitalidad: Aumenta en +" + text2 + " el HP máximo", 
				ScrollPerkType.RegHP => "Vitalis: Aumenta en +" + text2 + " la regeneración de HP", 
				ScrollPerkType.RegStamina => "Segundo Aliento: Aumenta en +" + text2 + " la regen. de Stamina", 
				ScrollPerkType.RegEitr => "Eco de Eitr: Aumenta en +" + text2 + " la regeneración de Eitr", 
				ScrollPerkType.Durabilidad => "Temple Reforjado: Aumenta en +" + text2 + " la durabilidad", 
				ScrollPerkType.Healing => "Sagrado: Aumenta en +" + text2 + " el poder de curación", 
				ScrollPerkType.ResistPierce => "Protección Perforante: Reduce en " + text2 + " el daño perforante recibido", 
				ScrollPerkType.ResistBlunt => "Protección Contundente: Reduce en " + text2 + " el daño contundente recibido", 
				ScrollPerkType.ResistSlash => "Protección Cortante: Reduce en " + text2 + " el daño cortante recibido", 
				ScrollPerkType.Bloqueo => "Aegis: Aumenta en +" + text2 + " el poder de bloqueo del escudo", 
				ScrollPerkType.Parry => "Contraataque: Aumenta en +" + text2 + " el multiplicador de parry", 
				ScrollPerkType.NoMovPen => "Sin Límites: Elimina la penalización de movimiento de la armadura", 
				ScrollPerkType.WeapSkill => "Destreza: Aumenta en +" + text2 + " la habilidad del arma equipada", 
				ScrollPerkType.Weight => "Sobrecarga: Aumenta en +" + text2 + " el peso máximo que puedes cargar", 
				_ => byName.DisplayName + ": +" + text2, 
			};
			if (1 == 0)
			{
			}
			string text4 = text3;
			return filledChar + " <color=#" + hex + ">" + text4 + "</color>";
		}

		private static string TranslateFaction(string faction)
		{
			if (1 == 0)
			{
			}
			string result = faction switch
			{
				"AnimalsVeg" => "Animales", 
				"ForestMonsters" => "Monstruos del Bosque", 
				"Undead" => "No Muertos", 
				"Demon" => "Demonios", 
				"MountainMonsters" => "Monstruos de Montaña", 
				"SeaMonsters" => "Monstruos del Mar", 
				"PlainsMonsters" => "Monstruos de Llanos", 
				"Boss" => "Jefes", 
				"MistlandsMonsters" => "Monstruos de Niebla", 
				"Dverger" => "Dverger", 
				_ => faction, 
			};
			if (1 == 0)
			{
			}
			return result;
		}
	}
	[HarmonyPatch]
	public static class ScrollDropPatch
	{
		[HarmonyPatch(typeof(Humanoid), "UseItem")]
		[HarmonyPrefix]
		public static bool UseItem_Prefix(Humanoid __instance, Inventory inventory, ItemData item, bool fromInventoryGui)
		{
			if (item == null)
			{
				return true;
			}
			if (!ScrollItem.IsEnchantScroll(item))
			{
				return true;
			}
			return false;
		}
	}
	public class ScrollEnchantUI : MonoBehaviour
	{
		private ItemData _scrollItem;

		private ItemData _targetItem;

		private bool _isOpen;

		private GameObject _titlePanel;

		private GameObject _leftPanel;

		private GameObject _rightPanel;

		private GameObject _bottomPanel;

		private Image _weaponIcon;

		private Text _weaponHint;

		private Text _weaponLabelText;

		private Image _scrollIcon;

		private Text _scrollPerkText;

		private Text _statusText;

		private Text _itemNameText;

		private Text _slotsAvailText;

		private Text _perksCurrentText;

		private Text _perksNewText;

		private Text _smithLevelText;

		private Button _acceptBtn;

		private Image _coinIcon;

		private Text _coinCostText;

		private const float LeftW = 300f;

		private const float RightW = 460f;

		private const float BodyH = 540f;

		private const float Gap = 10f;

		private const float TotalW = 770f;

		private const float BottomH = 80f;

		private const string COIN_PREFAB_NAME = "Coins";

		private Text _titleText;

		public static ScrollEnchantUI Instance { get; private set; }

		private static int GetSmithLevelRequired(ItemRarity rarity)
		{
			if (1 == 0)
			{
			}
			int result = rarity switch
			{
				ItemRarity.Common => 0, 
				ItemRarity.Uncommon => 10, 
				ItemRarity.Rare => 25, 
				ItemRarity.Epic => 50, 
				ItemRarity.Legendary => 75, 
				_ => 0, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static int GetCoinCost(ItemRarity rarity)
		{
			if (1 == 0)
			{
			}
			int result = rarity switch
			{
				ItemRarity.Common => 0, 
				ItemRarity.Uncommon => 250, 
				ItemRarity.Rare => 350, 
				ItemRarity.Epic => 1000, 
				ItemRarity.Legendary => 2500, 
				_ => 0, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private void Awake()
		{
			Instance = this;
			GUIManager.OnCustomGUIAvailable += OnGUIAvailable;
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
			GUIManager.OnCustomGUIAvailable -= OnGUIAvailable;
		}

		private void OnGUIAvailable()
		{
			Object.Destroy((Object)(object)_titlePanel);
			_titlePanel = null;
			Object.Destroy((Object)(object)_leftPanel);
			_leftPanel = null;
			Object.Destroy((Object)(object)_rightPanel);
			_rightPanel = null;
			Object.Destroy((Object)(object)_bottomPanel);
			_bottomPanel = null;
			EnsurePanel();
		}

		private void Update()
		{
		}

		public void Open(ItemData scrollItem)
		{
			if (scrollItem != null)
			{
				_scrollItem = scrollItem;
				_targetItem = null;
				EnsurePanel();
				if (!((Object)(object)_titlePanel == (Object)null))
				{
					RefreshUI();
					_titlePanel.SetActive(true);
					_leftPanel.SetActive(true);
					_rightPanel.SetActive(true);
					_bottomPanel.SetActive(true);
					_isOpen = true;
				}
			}
		}

		public void Close()
		{
			((MonoBehaviour)this).CancelInvoke("Close");
			_isOpen = false;
			GameObject titlePanel = _titlePanel;
			if (titlePanel != null)
			{
				titlePanel.SetActive(false);
			}
			GameObject leftPanel = _leftPanel;
			if (leftPanel != null)
			{
				leftPanel.SetActive(false);
			}
			GameObject rightPanel = _rightPanel;
			if (rightPanel != null)
			{
				rightPanel.SetActive(false);
			}
			GameObject bottomPanel = _bottomPanel;
			if (bottomPanel != null)
			{
				bottomPanel.SetActive(false);
			}
			_scrollItem = null;
			_targetItem = null;
		}

		public void TrySetTarget(ItemData item)
		{
			if (_isOpen && item != null && RarityPatches.IsWeaponOrArmor(item))
			{
				_targetItem = item;
				RefreshUI();
			}
		}

		private void EnsurePanel()
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0505: Unknown result type (might be due to invalid IL or missing references)
			//IL_0527: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_0658: Unknown result type (might be due to invalid IL or missing references)
			//IL_0682: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06de: Unknown result type (might be due to invalid IL or missing references)
			//IL_070b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0718: Unknown result type (might be due to invalid IL or missing references)
			//IL_071f: Expected O, but got Unknown
			//IL_0756: Unknown result type (might be due to invalid IL or missing references)
			//IL_075e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0772: Unknown result type (might be due to invalid IL or missing references)
			//IL_0789: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fe: Expected O, but got Unknown
			//IL_0828: Unknown result type (might be due to invalid IL or missing references)
			//IL_083f: Unknown result type (might be due to invalid IL or missing references)
			//IL_084e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0853: Unknown result type (might be due to invalid IL or missing references)
			//IL_0854: Unknown result type (might be due to invalid IL or missing references)
			//IL_085c: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0907: Unknown result type (might be due to invalid IL or missing references)
			//IL_093c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0946: Expected O, but got Unknown
			//IL_0966: Unknown result type (might be due to invalid IL or missing references)
			//IL_0975: Unknown result type (might be due to invalid IL or missing references)
			//IL_0984: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b7: Expected O, but got Unknown
			if (!((Object)(object)_titlePanel != (Object)null) && GUIManager.Instance != null && !((Object)(object)GUIManager.CustomGUIFront == (Object)null))
			{
				float num = -235f;
				float num2 = 155f;
				float num3 = 302f;
				float num4 = -316f;
				Color color = default(Color);
				((Color)(ref color))..ctor(0.08f, 0.06f, 0.06f, 0.97f);
				_titlePanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, num3), 770f, 58f, true);
				_titlePanel.SetActive(false);
				DarkenPanel(_titlePanel, color);
				GameObject val = GUIManager.Instance.CreateText("Encantamiento", _titlePanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, GUIManager.Instance.AveriaSerifBold, 27, GUIManager.Instance.ValheimOrange, true, Color.black, 750f, 35f, false);
				_titleText = val.GetComponent<Text>();
				_titleText.alignment = (TextAnchor)4;
				_leftPanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(num, 0f), 300f, 540f, false);
				_leftPanel.SetActive(false);
				DarkenPanel(_leftPanel, color);
				float num5 = 170f;
				float num6 = -60f;
				GameObject val2 = GUIManager.Instance.CreateText("Arma / Armadura", _leftPanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, num5 + 68f), GUIManager.Instance.AveriaSerifBold, 17, GUIManager.Instance.ValheimOrange, true, Color.black, 260f, 25f, false);
				_weaponLabelText = val2.GetComponent<Text>();
				_weaponLabelText.alignment = (TextAnchor)4;
				GameObject val3 = CreateSlot(_leftPanel.transform, new Vector2(0f, num5));
				_weaponIcon = ((Component)val3.transform.Find("Icon")).GetComponent<Image>();
				_weaponHint = MakeText(_leftPanel.transform, new Vector2(0f, num5), 105f, 105f, 14);
				_weaponHint.text = "Click\nizquierdo";
				((Graphic)_weaponHint).color = new Color(0.5f, 0.5f, 0.5f);
				_weaponHint.alignment = (TextAnchor)4;
				MakeSep(_leftPanel.transform, new Vector2(0f, num5 - 78f));
				MakeLabel(_leftPanel.transform, "Pergamino", new Vector2(0f, num6 + 68f), 260f, 17, orange: true);
				GameObject val4 = CreateSlot(_leftPanel.transform, new Vector2(0f, num6));
				_scrollIcon = ((Component)val4.transform.Find("Icon")).GetComponent<Image>();
				_scrollPerkText = MakeText(_leftPanel.transform, new Vector2(0f, num6 - 68f), 270f, 27f, 14);
				_scrollPerkText.alignment = (TextAnchor)4;
				_rightPanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(num2, 0f), 460f, 540f, false);
				_rightPanel.SetActive(false);
				DarkenPanel(_rightPanel, color);
				_itemNameText = MakeText(_rightPanel.transform, new Vector2(0f, 228f), 420f, 30f, 25);
				_itemNameText.alignment = (TextAnchor)4;
				((Graphic)_itemNameText).color = GUIManager.Instance.ValheimOrange;
				_slotsAvailText = MakeText(_rightPanel.transform, new Vector2(0f, 198f), 420f, 22f, 19);
				_slotsAvailText.alignment = (TextAnchor)4;
				((Graphic)_slotsAvailText).color = new Color(0.75f, 0.75f, 0.75f);
				MakeSep(_rightPanel.transform, new Vector2(0f, 172f));
				_statusText = MakeText(_rightPanel.transform, new Vector2(0f, 138f), 420f, 28f, 20);
				_statusText.alignment = (TextAnchor)4;
				_smithLevelText = MakeText(_rightPanel.transform, new Vector2(0f, 110f), 420f, 24f, 17);
				_smithLevelText.alignment = (TextAnchor)4;
				MakeSep(_rightPanel.transform, new Vector2(0f, 86f));
				MakeLabel(_rightPanel.transform, "Perks actuales:", new Vector2(0f, 64f), 420f, 21);
				_perksCurrentText = MakeText(_rightPanel.transform, new Vector2(0f, -2f), 420f, 80f, 22);
				_perksCurrentText.alignment = (TextAnchor)1;
				MakeSep(_rightPanel.transform, new Vector2(0f, -50f));
				MakeLabel(_rightPanel.transform, "Con este encanto:", new Vector2(0f, -72f), 420f, 21);
				_perksNewText = MakeText(_rightPanel.transform, new Vector2(0f, -138f), 420f, 80f, 22);
				_perksNewText.alignment = (TextAnchor)1;
				_bottomPanel = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(0f, num4), 770f, 80f, false);
				_bottomPanel.SetActive(false);
				DarkenPanel(_bottomPanel, color);
				GameObject val5 = new GameObject("CoinSlot");
				val5.transform.SetParent(_bottomPanel.transform, false);
				RectTransform val6 = val5.AddComponent<RectTransform>();
				Vector2 val7 = default(Vector2);
				((Vector2)(ref val7))..ctor(0.5f, 0.5f);
				val6.anchorMax = val7;
				val6.anchorMin = val7;
				val6.anchoredPosition = new Vector2(-345f, 0f);
				val6.sizeDelta = new Vector2(40f, 40f);
				Image val8 = val5.AddComponent<Image>();
				Sprite sprite = GUIManager.Instance.GetSprite("item_background");
				if ((Object)(object)sprite != (Object)null)
				{
					val8.sprite = sprite;
					val8.type = (Type)1;
				}
				((Graphic)val8).color = new Color(0.1f, 0.1f, 0.1f, 0.6f);
				GameObject val9 = new GameObject("CoinIcon");
				val9.transform.SetParent(val5.transform, false);
				RectTransform val10 = val9.AddComponent<RectTransform>();
				val10.anchorMin = new Vector2(0.1f, 0.1f);
				val10.anchorMax = new Vector2(0.9f, 0.9f);
				val7 = (val10.offsetMin = (val10.offsetMax = Vector2.zero));
				_coinIcon = val9.AddComponent<Image>();
				((Behaviour)_coinIcon).enabled = false;
				((Graphic)_coinIcon).raycastTarget = false;
				_coinCostText = MakeText(_bottomPanel.transform, new Vector2(-270f, 0f), 100f, 36f, 17);
				_coinCostText.alignment = (TextAnchor)3;
				GameObject val12 = GUIManager.Instance.CreateButton("ENCANTAR", _bottomPanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(-110f, 0f), 180f, 50f);
				_acceptBtn = val12.GetComponent<Button>();
				((UnityEvent)_acceptBtn.onClick).AddListener(new UnityAction(OnAccept));
				GameObject val13 = GUIManager.Instance.CreateButton("CANCELAR", _bottomPanel.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), new Vector2(110f, 0f), 180f, 50f);
				((UnityEvent)val13.GetComponent<Button>().onClick).AddListener(new UnityAction(Close));
			}
		}

		private static void DarkenPanel(GameObject panel, Color color)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("DarkBG");
			val.transform.SetParent(panel.transform, false);
			val.transform.SetAsFirstSibling();
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			Vector2 offsetMin = (val2.offsetMax = Vector2.zero);
			val2.offsetMin = offsetMin;
			((Graphic)val.AddComponent<Image>()).color = color;
		}

		private void RefreshUI()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0556: Unknown result type (might be due to invalid IL or missing references)
			//IL_0654: Unknown result type (might be due to invalid IL or missing references)
			if (_scrollItem == null || (Object)(object)_scrollIcon == (Object)null)
			{
				return;
			}
			ScrollItem.TryGetScrollTier(_scrollItem, out var rarity);
			ScrollItem.TryGetScrollPerk(_scrollItem, out var perk);
			RarityInfo rarityInfo = RarityData.Info[rarity];
			string text = ColorUtility.ToHtmlStringRGB(rarityInfo.Color);
			_scrollIcon.sprite = _scrollItem.GetIcon();
			((Behaviour)_scrollIcon).enabled = true;
			_scrollPerkText.text = ((perk != null) ? ("<color=#" + text + ">" + perk.GetDisplayText(rarity) + "</color>") : ("<color=#" + text + ">" + rarityInfo.Name + "</color>"));
			if ((Object)(object)_titleText != (Object)null)
			{
				((Graphic)_titleText).color = rarityInfo.Color;
			}
			int coinCost = GetCoinCost(rarity);
			RefreshCoinSlot(rarity, coinCost);
			bool flag = _targetItem != null;
			((Component)_weaponHint).gameObject.SetActive(!flag);
			_weaponIcon.sprite = (flag ? _targetItem.GetIcon() : null);
			((Behaviour)_weaponIcon).enabled = flag;
			if ((Object)(object)_weaponLabelText != (Object)null)
			{
				if (!flag)
				{
					_weaponLabelText.text = "Arma / Armadura";
				}
				else
				{
					_weaponLabelText.text = GetItemCategoryLabel(_targetItem);
				}
			}
			if (!flag)
			{
				_statusText.text = "<color=#aaaaaa>Encanto: En espera</color>";
				_itemNameText.text = "—";
				_slotsAvailText.text = "";
				_smithLevelText.text = "";
				_perksCurrentText.text = "";
				_perksNewText.text = "";
				((Selectable)_acceptBtn).interactable = false;
				return;
			}
			string text2 = ((Localization.instance != null) ? Localization.instance.Localize(_targetItem.m_shared.m_name) : _targetItem.m_shared.m_name);
			_itemNameText.text = text2;
			RarityItemData rarityItemData = RarityTooltip.Get(_targetItem);
			if (rarityItemData != null)
			{
				_slotsAvailText.text = $"Slots disponibles: {rarityItemData.EmptySlots}";
			}
			else
			{
				_slotsAvailText.text = "";
			}
			int smithLevelRequired = GetSmithLevelRequired(rarity);
			bool flag2 = CheckSmithLevel(smithLevelRequired);
			int currentSmithLevel = GetCurrentSmithLevel();
			if (smithLevelRequired > 0)
			{
				string text3 = (flag2 ? "88ff88" : "ff4444");
				string text4 = (flag2 ? "✔" : "✘");
				_smithLevelText.text = $"<color=#{text3}>{text4} Herrería requerida: {smithLevelRequired}  (Actual: {currentSmithLevel})</color>";
			}
			else
			{
				_smithLevelText.text = "<color=#88ff88>✔ Sin requisito de Herrería</color>";
			}
			bool flag3 = CheckCoins(coinCost);
			string text5;
			if (rarityItemData == null)
			{
				text5 = "<color=#ff4444>Sin rareza asignada</color>";
				((Selectable)_acceptBtn).interactable = false;
			}
			else if (rarityItemData.Rarity != rarity)
			{
				string name = RarityData.Info[rarity].Name;
				text5 = "<color=#ff4444>El item debe ser " + name + "</color>";
				((Selectable)_acceptBtn).interactable = false;
			}
			else if (!rarityItemData.HasFreeSlot)
			{
				text5 = "<color=#ff4444>Sin slots libres</color>";
				((Selectable)_acceptBtn).interactable = false;
			}
			else if (!flag3)
			{
				text5 = $"<color=#ff4444>Necesitas {coinCost} monedas</color>";
				((Selectable)_acceptBtn).interactable = false;
			}
			else
			{
				ScrollItem.TryGetScrollPerk(_scrollItem, out var perk2);
				string text6 = ((perk2 != null) ? CheckPerkItemRestriction(perk2, _targetItem) : null);
				string text7 = ((text6 == null && perk2 != null) ? CheckPerkCompatibility(rarityItemData, perk2) : null);
				if (text6 != null)
				{
					text5 = "<color=#ff4444>" + text6 + "</color>";
					((Selectable)_acceptBtn).interactable = false;
				}
				else if (text7 != null)
				{
					text5 = "<color=#ff4444>" + text7 + "</color>";
					((Selectable)_acceptBtn).interactable = false;
				}
				else if (!flag2)
				{
					text5 = $"<color=#ff4444>Necesitas nivel {smithLevelRequired} de Herrería</color>";
					((Selectable)_acceptBtn).interactable = false;
				}
				else
				{
					text5 = "<color=#88ff88>Encanto: Posible ✔</color>";
					((Selectable)_acceptBtn).interactable = true;
				}
			}
			_statusText.text = text5;
			if (rarityItemData != null && rarityItemData.FilledSlots > 0)
			{
				string text8 = ColorUtility.ToHtmlStringRGB(RarityData.Info[rarityItemData.Rarity].Color);
				string text9 = "";
				foreach (string insertedScrollId in rarityItemData.InsertedScrollIds)
				{
					if (!string.IsNullOrEmpty(insertedScrollId))
					{
						text9 = text9 + "<color=#" + text8 + ">• " + FormatPerkId(insertedScrollId, rarityItemData.Rarity) + "</color>\n";
					}
				}
				_perksCurrentText.text = text9.TrimEnd(Array.Empty<char>());
			}
			else
			{
				_perksCurrentText.text = "<color=#888888>Sin perks</color>";
			}
			if (rarityItemData != null && rarityItemData.Rarity == rarity && rarityItemData.HasFreeSlot && perk != null)
			{
				string text10 = ColorUtility.ToHtmlStringRGB(RarityData.Info[rarityItemData.Rarity].Color);
				string text11 = "";
				foreach (string insertedScrollId2 in rarityItemData.InsertedScrollIds)
				{
					if (!string.IsNullOrEmpty(insertedScrollId2))
					{
						text11 = text11 + "<color=#" + text10 + ">• " + insertedScrollId2 + "</color>\n";
					}
				}
				text11 = text11 + "<color=#" + text + ">+ " + perk.GetDisplayText(rarity) + "</color>";
				_perksNewText.text = text11;
			}
			else if (rarityItemData != null && !rarityItemData.HasFreeSlot)
			{
				_perksNewText.text = "<color=#ff6666>Sin slots disponibles</color>";
			}
			else
			{
				_perksNewText.text = "<color=#888888>—</color>";
			}
		}

		private static int GetCurrentSmithLevel()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return 0;
			}
			SkillType val = (SkillType)StringExtensionMethods.GetStableHashCode("nazhi.blacksmithing.skill");
			return Mathf.FloorToInt(((Character)localPlayer).GetSkillLevel(val));
		}

		private static bool CheckSmithLevel(int required)
		{
			if (required <= 0)
			{
				return true;
			}
			return GetCurrentSmithLevel() >= required;
		}

		private static int GetPlayerCoinCount()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return 0;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			if (inventory == null)
			{
				return 0;
			}
			return inventory.CountItems("$item_coins", -1, true);
		}

		private static bool CheckCoins(int required)
		{
			if (required <= 0)
			{
				return true;
			}
			return GetPlayerCoinCount() >= required;
		}

		private void RefreshCoinSlot(ItemRarity rarity, int cost)
		{
			if ((Object)(object)_coinCostText == (Object)null)
			{
				return;
			}
			if ((Object)(object)_coinIcon != (Object)null && (Object)(object)ZNetScene.instance != (Object)null && !((Behaviour)_coinIcon).enabled)
			{
				GameObject prefab = ZNetScene.instance.GetPrefab("Coins");
				if ((Object)(object)prefab != (Object)null)
				{
					ItemDrop component = prefab.GetComponent<ItemDrop>();
					if (component?.m_itemData != null)
					{
						_coinIcon.sprite = component.m_itemData.GetIcon();
						((Behaviour)_coinIcon).enabled = (Object)(object)_coinIcon.sprite != (Object)null;
					}
				}
			}
			if (cost <= 0)
			{
				_coinCostText.text = "<color=#888888>Gratis</color>";
				return;
			}
			bool flag = CheckCoins(cost);
			int playerCoinCount = GetPlayerCoinCount();
			string arg = (flag ? "f0c040" : "ff4444");
			_coinCostText.text = $"<color=#{arg}>{playerCoinCount}/{cost}\n<size=13>monedas</size></color>";
		}

		private void OnAccept()
		{
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			if (_scrollItem == null || _targetItem == null)
			{
				return;
			}
			ScrollItem.TryGetScrollTier(_scrollItem, out var rarity);
			ScrollItem.TryGetScrollPerk(_scrollItem, out var perk);
			RarityItemData rarityItemData = RarityTooltip.Get(_targetItem);
			if (rarityItemData == null || !rarityItemData.HasFreeSlot || rarityItemData.Rarity != rarity)
			{
				return;
			}
			int smithLevelRequired = GetSmithLevelRequired(rarity);
			if (!CheckSmithLevel(smithLevelRequired))
			{
				_statusText.text = $"<color=#ff4444>Necesitas nivel {smithLevelRequired} de Herrería</color>";
				return;
			}
			int coinCost = GetCoinCost(rarity);
			if (!CheckCoins(coinCost))
			{
				_statusText.text = $"<color=#ff4444>Necesitas {coinCost} monedas</color>";
				return;
			}
			string text = ((perk != null) ? CheckPerkItemRestriction(perk, _targetItem) : null);
			if (text != null)
			{
				_statusText.text = "<color=#ff4444>Encanto: No es Posible  <size=16>· " + text + "</size></color>";
				return;
			}
			string text2 = ((perk != null) ? CheckPerkCompatibility(rarityItemData, perk) : null);
			if (text2 != null)
			{
				_statusText.text = "<color=#ff6666>Encanto: " + text2 + "</color>";
				return;
			}
			if (coinCost > 0)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Humanoid)localPlayer).GetInventory().RemoveItem("Coins", coinCost, -1, true);
				}
			}
			string scrollPerkId = perk?.DisplayName ?? "???";
			if (perk != null && perk.Type == ScrollPerkType.DmgFaccion)
			{
				Faction[] array = new Faction[10];
				RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
				Faction[] array2 = (Faction[])(object)array;
				Faction val = array2[Random.Range(0, array2.Length)];
				scrollPerkId = $"Daño a Faccion:{val}";
			}
			rarityItemData.InsertScroll(scrollPerkId);
			RarityTooltip.Save(_targetItem, rarityItemData);
			Player localPlayer2 = Player.m_localPlayer;
			if (localPlayer2 != null)
			{
				((Humanoid)localPlayer2).GetInventory().RemoveOneItem(_scrollItem);
			}
			EnchantBonusManager.RefreshSingleItem(_targetItem);
			EnchantBonusManager.Refresh(Player.m_localPlayer);
			_statusText.text = "<color=#88ff88>✔ ¡Encantamiento aplicado!</color>";
			((Selectable)_acceptBtn).interactable = false;
			((MonoBehaviour)this).Invoke("Close", 1.2f);
		}

		private GameObject CreateSlot(Transform parent, Vector2 pos)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Slot");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			val2.anchorMax = val3;
			val2.anchorMin = val3;
			val2.anchoredPosition = pos;
			val2.sizeDelta = new Vector2(108f, 108f);
			Image val4 = val.AddComponent<Image>();
			Sprite sprite = GUIManager.Instance.GetSprite("item_background");
			if ((Object)(object)sprite != (Object)null)
			{
				val4.sprite = sprite;
				val4.type = (Type)1;
			}
			((Graphic)val4).color = Color.white;
			Button val5 = val.AddComponent<Button>();
			((Selectable)val5).targetGraphic = (Graphic)(object)val4;
			ColorBlock val6 = default(ColorBlock);
			((ColorBlock)(ref val6)).normalColor = new Color(0.1324f, 0.1324f, 0.1324f, 0.502f);
			((ColorBlock)(ref val6)).highlightedColor = new Color(0.3897f, 0.4012f, 0.4012f, 0.502f);
			((ColorBlock)(ref val6)).pressedColor = new Color(0.2794f, 0.2794f, 0.2794f, 1f);
			((ColorBlock)(ref val6)).selectedColor = new Color(0.3897f, 0.4012f, 0.4012f, 0.502f);
			((ColorBlock)(ref val6)).disabledColor = new Color(0f, 0f, 0f, 0.502f);
			((ColorBlock)(ref val6)).colorMultiplier = 1f;
			((ColorBlock)(ref val6)).fadeDuration = 0.1f;
			ColorBlock colors = val6;
			((Selectable)val5).colors = colors;
			GameObject val7 = new GameObject("Icon");
			val7.transform.SetParent(val.transform, false);
			RectTransform val8 = val7.AddComponent<RectTransform>();
			val8.anchorMin = new Vector2(0.1f, 0.1f);
			val8.anchorMax = new Vector2(0.9f, 0.9f);
			val3 = (val8.offsetMin = (val8.offsetMax = Vector2.zero));
			Image val10 = val7.AddComponent<Image>();
			((Behaviour)val10).enabled = false;
			((Graphic)val10).raycastTarget = false;
			return val;
		}

		private void MakeLabel(Transform parent, string text, Vector2 pos, float width, int fontSize, bool orange = false)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GUIManager.Instance.CreateText(text, parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), pos, GUIManager.Instance.AveriaSerifBold, fontSize, (Color)(orange ? GUIManager.Instance.ValheimOrange : new Color(0.75f, 0.75f, 0.75f)), orange, Color.black, width, (float)fontSize + 8f, false);
			val.GetComponent<Text>().alignment = (TextAnchor)4;
		}

		private static string GetItemCategoryLabel(ItemData item)
		{
			//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_001f: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			if (item == null)
			{
				return "Arma / Armadura";
			}
			ItemType itemType = item.m_shared.m_itemType;
			if ((int)itemType == 5)
			{
				return "Escudo";
			}
			if ((int)itemType == 3 || (int)itemType == 14 || (int)itemType == 4)
			{
				return "Arma";
			}
			return "Armadura";
		}

		private static bool IsWeaponType(ItemData item)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			if (item == null)
			{
				return false;
			}
			ItemType itemType = item.m_shared.m_itemType;
			return (int)itemType == 3 || (int)itemType == 14 || (int)itemType == 4;
		}

		private static bool IsArmorType(ItemData item)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			if (item == null)
			{
				return false;
			}
			ItemType itemType = item.m_shared.m_itemType;
			return (int)itemType == 6 || (int)itemType == 7 || (int)itemType == 11 || (int)itemType == 17;
		}

		private static bool IsShieldType(ItemData item)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			if (item == null)
			{
				return false;
			}
			return (int)item.m_shared.m_itemType == 5;
		}

		private static string CheckPerkItemRestriction(ScrollPerkDef perk, ItemData item)
		{
			if (perk == null || item == null)
			{
				return null;
			}
			bool flag = IsWeaponType(item);
			bool flag2 = IsArmorType(item);
			bool flag3 = IsShieldType(item);
			switch (perk.Type)
			{
			case ScrollPerkType.Pierce:
			case ScrollPerkType.Blunt:
			case ScrollPerkType.Slash:
			case ScrollPerkType.DmgFaccion:
			case ScrollPerkType.VelocidadAtk:
			case ScrollPerkType.DmgMagico:
				if (!flag)
				{
					return "Solo se puede aplicar a armas";
				}
				break;
			case ScrollPerkType.WeapSkill:
				if (!flag && !flag3)
				{
					return "Solo se puede aplicar a armas o escudos";
				}
				break;
			case ScrollPerkType.ReduccionDmg:
			case ScrollPerkType.Vida:
			case ScrollPerkType.Armadura:
			case ScrollPerkType.RegHP:
			case ScrollPerkType.RegStamina:
			case ScrollPerkType.RegEitr:
			case ScrollPerkType.ResistPierce:
			case ScrollPerkType.ResistBlunt:
			case ScrollPerkType.ResistSlash:
				if (!flag2)
				{
					return "Solo se puede aplicar a armaduras";
				}
				break;
			case ScrollPerkType.NoMovPen:
				if (!flag2 && !flag3)
				{
					return "Solo se puede aplicar a armaduras o escudos";
				}
				break;
			}
			return null;
		}

		private static string CheckPerkCompatibility(RarityItemData rd, ScrollPerkDef perk)
		{
			foreach (string insertedScrollId in rd.InsertedScrollIds)
			{
				if (string.IsNullOrEmpty(insertedScrollId))
				{
					continue;
				}
				string displayName = insertedScrollId.Split(new char[1] { ':' })[0];
				ScrollPerkDef byName = ScrollPerkRegistry.GetByName(displayName);
				if (byName != null)
				{
					bool flag = perk.Type == ScrollPerkType.Armadura;
					bool flag2 = perk.Type == ScrollPerkType.Vida;
					bool flag3 = byName.Type == ScrollPerkType.Armadura;
					bool flag4 = byName.Type == ScrollPerkType.Vida;
					if (flag && flag4)
					{
						return "Incompatible con Vida";
					}
					if (flag2 && flag3)
					{
						return "Incompatible con Armadura";
					}
					if (isRegen(perk.Type) && isRegen(byName.Type) && perk.Type != byName.Type)
					{
						return "Incompatible con " + byName.DisplayName;
					}
				}
			}
			return null;
			static bool isRegen(ScrollPerkType t)
			{
				return t == ScrollPerkType.RegHP || t == ScrollPerkType.RegStamina || t == ScrollPerkType.RegEitr;
			}
		}

		private static string FormatPerkId(string id, ItemRarity rarity)
		{
			string[] array = id.Split(new char[1] { ':' });
			if (array.Length == 2)
			{
				ScrollPerkDef byName = ScrollPerkRegistry.GetByName(array[0]);
				if (byName != null)
				{
					return byName.GetDisplayText(rarity) + " vs " + array[1];
				}
			}
			ScrollPerkDef byName2 = ScrollPerkRegistry.GetByName(id);
			return (byName2 != null) ? byName2.GetDisplayText(rarity) : id;
		}

		private Text MakeText(Transform parent, Vector2 pos, float w, float h, int fontSize)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GUIManager.Instance.CreateText("", parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), pos, GUIManager.Instance.AveriaSerifBold, fontSize, Color.white, false, Color.black, w, h, false);
			return val.GetComponent<Text>();
		}

		private void MakeSep(Transform parent, Vector2 pos)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Sep");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(0.5f, 0.5f);
			val2.anchorMax = val3;
			val2.anchorMin = val3;
			val2.anchoredPosition = pos;
			val2.sizeDelta = new Vector2(310f, 1f);
			((Graphic)val.AddComponent<Image>()).color = new Color(1f, 1f, 1f, 0.12f);
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnRightClickItem")]
	public static class ScrollUIPatch
	{
		private static int _revealedFrame = -1;

		[HarmonyPrefix]
		public static bool Prefix(InventoryGui __instance, InventoryGrid grid, ItemData item)
		{
			if (item == null || !ScrollItem.IsEnchantScroll(item))
			{
				return true;
			}
			if (item.m_customData == null || !item.m_customData.TryGetValue("ScrollRevealed", out var value) || !(value == "1"))
			{
				ScrollItem.TryGetScrollTier(item, out var rarity);
				ScrollItem.RollPerk(rarity, out var perkKey, out var _);
				if (item.m_customData == null)
				{
					item.m_customData = new Dictionary<string, string>();
				}
				item.m_customData["ScrollPerk"] = perkKey;
				item.m_customData["ScrollRevealed"] = "1";
				_revealedFrame = Time.frameCount;
				Logger.LogInfo((object)$"[Scroll] Revelado: {perkKey} ({rarity})");
				return false;
			}
			if (Time.frameCount == _revealedFrame)
			{
				return false;
			}
			if ((Object)(object)ScrollEnchantUI.Instance == (Object)null)
			{
				return true;
			}
			ScrollEnchantUI.Instance.Open(item);
			return false;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "Hide")]
	public static class ScrollEnchantInventoryHidePatch
	{
		[HarmonyPostfix]
		public static void Postfix()
		{
			if (!((Object)(object)ScrollEnchantUI.Instance == (Object)null))
			{
				FieldInfo field = typeof(ScrollEnchantUI).GetField("_isOpen", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field != null && (bool)field.GetValue(ScrollEnchantUI.Instance))
				{
					ScrollEnchantUI.Instance.Close();
				}
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "OnSelectedItem")]
	public static class ScrollTargetPickPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(InventoryGrid grid, ItemData item, Vector2i pos, Modifier mod)
		{
			if ((Object)(object)ScrollEnchantUI.Instance == (Object)null)
			{
				return true;
			}
			FieldInfo field = typeof(ScrollEnchantUI).GetField("_isOpen", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null || !(bool)field.GetValue(ScrollEnchantUI.Instance))
			{
				return true;
			}
			if (item == null || !RarityPatches.IsWeaponOrArmor(item))
			{
				return true;
			}
			ScrollEnchantUI.Instance.TrySetTarget(item);
			return false;
		}
	}
	public static class ScrollItem
	{
		public static readonly Dictionary<ItemRarity, string> PrefabNames = new Dictionary<ItemRarity, string>
		{
			{
				ItemRarity.Uncommon,
				"NC_Scroll_Uncommon"
			},
			{
				ItemRarity.Rare,
				"NC_Scroll_Rare"
			},
			{
				ItemRarity.Epic,
				"NC_Scroll_Epic"
			},
			{
				ItemRarity.Legendary,
				"NC_Scroll_Legendary"
			}
		};

		public static readonly Dictionary<string, (ItemRarity rarity, float chance)[]> DropTable = new Dictionary<string, (ItemRarity, float)[]>
		{
			{
				"Boar",
				new(ItemRarity, float)[4]
				{
					(ItemRarity.Uncommon, 0.05f),
					(ItemRarity.Rare, 0.03f),
					(ItemRarity.Epic, 0.01f),
					(ItemRarity.Legendary, 0.001f)
				}
			},
			{
				"Neck",
				new(ItemRarity, float)[4]
				{
					(ItemRarity.Uncommon, 0.05f),
					(ItemRarity.Rare, 0.03f),
					(ItemRarity.Epic, 0.01f),
					(ItemRarity.Legendary, 0.001f)
				}
			},
			{
				"Greydwarf",
				new(ItemRarity, float)[4]
				{
					(ItemRarity.Uncommon, 0.05f),
					(ItemRarity.Rare, 0.02f),
					(ItemRarity.Epic, 0.01f),
					(ItemRarity.Legendary, 0.001f)
				}
			}
		};

		public const string SCROLL_TIER_KEY = "ScrollTier";

		public const string SCROLL_PERK_KEY = "ScrollPerk";

		public const string SCROLL_REVEALED_KEY = "ScrollRevealed";

		public static void Register()
		{
			PrefabManager.OnVanillaPrefabsAvailable += OnPrefabsAvailable;
		}

		private static void OnPrefabsAvailable()
		{
			PrefabManager.OnVanillaPrefabsAvailable -= OnPrefabsAvailable;
			foreach (ItemRarity key in PrefabNames.Keys)
			{
				RegisterScrollForRarity(key);
			}
		}

		private static void RegisterScrollForRarity(ItemRarity rarity)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			string text = PrefabNames[rarity];
			if (!((Object)(object)PrefabManager.Instance.GetPrefab(text) != (Object)null))
			{
				CustomItem val = new CustomItem(text, "ReturnScroll");
				if (!((Object)(object)((val != null) ? val.ItemDrop : null) == (Object)null))
				{
					SharedData shared = val.ItemDrop.m_itemData.m_shared;
					RarityInfo rarityInfo = RarityData.Info[rarity];
					shared.m_name = "Pergamino de Encantamiento [" + rarityInfo.Name + "]";
					shared.m_description = BuildLockedDescription(rarity);
					shared.m_itemType = (ItemType)16;
					shared.m_maxStackSize = 1;
					shared.m_consumeStatusEffect = null;
					shared.m_food = 0f;
					shared.m_foodStamina = 0f;
					shared.m_foodBurnTime = 0f;
					shared.m_foodRegen = 0f;
					ItemManager.Instance.AddItem(val);
					Logger.LogInfo((object)("[Scroll] Registrado " + text + " (" + rarityInfo.Name + ")"));
				}
			}
		}

		public static string BuildLockedDescription(ItemRarity rarity)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			RarityInfo rarityInfo = RarityData.Info[rarity];
			string text = ColorUtility.ToHtmlStringRGB(rarityInfo.Color);
			return "<color=#" + text + ">Pergamino " + rarityInfo.Name + "</color>\n<color=#aaaaaa>[ Bloqueado — Click derecho para revelar el encantamiento ]</color>";
		}

		public static string BuildRevealedDescription(ItemRarity rarity, string perkDisplay)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			RarityInfo rarityInfo = RarityData.Info[rarity];
			string text = ColorUtility.ToHtmlStringRGB(rarityInfo.Color);
			return "<color=#" + text + "><b>" + rarityInfo.Name + " Scroll</b></color>\n<color=#" + text + ">" + perkDisplay + "</color>\nClick derecho para encantar un arma o armadura con slot disponible.";
		}

		public static bool IsEnchantScroll(ItemData item)
		{
			return item?.m_shared.m_name.StartsWith("Pergamino de Encantamiento") ?? false;
		}

		public static bool IsRevealed(ItemData item)
		{
			if (item == null)
			{
				return false;
			}
			string value;
			return item.m_customData.TryGetValue("ScrollRevealed", out value) && value == "1";
		}

		public static void RollPerk(ItemRarity rarity, out string perkKey, out string perkDisplay)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			ScrollPerkDef scrollPerkDef = ScrollPerkRegistry.All.OrderBy((ScrollPerkDef _) => Random.value).FirstOrDefault();
			if (scrollPerkDef != null && scrollPerkDef.Type == ScrollPerkType.DmgFaccion)
			{
				Faction[] array = new Faction[10];
				RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
				Faction[] array2 = (Faction[])(object)array;
				Faction val = array2[Random.Range(0, array2.Length)];
				perkKey = $"Daño a Faccion:{val}";
				perkDisplay = $"{scrollPerkDef.GetDisplayText(rarity)} vs {val}";
			}
			else if (scrollPerkDef != null)
			{
				perkKey = scrollPerkDef.DisplayName;
				perkDisplay = scrollPerkDef.GetDisplayText(rarity);
			}
			else
			{
				perkKey = string.Empty;
				perkDisplay = string.Empty;
			}
		}

		public static bool TryGetScrollTier(ItemData item, out ItemRarity rarity)
		{
			rarity = ItemRarity.Common;
			if (item == null)
			{
				return false;
			}
			if (item.m_customData.TryGetValue("ScrollTier", out var value) && int.TryParse(value, out var result))
			{
				rarity = (ItemRarity)result;
				return true;
			}
			foreach (KeyValuePair<ItemRarity, string> prefabName in PrefabNames)
			{
				if ((Object)(object)item.m_dropPrefab != (Object)null && ((Object)item.m_dropPrefab).name == prefabName.Value)
				{
					rarity = prefabName.Key;
					return true;
				}
			}
			return false;
		}

		public static bool TryGetScrollPerk(ItemData item, out ScrollPerkDef perk)
		{
			perk = null;
			if (item == null)
			{
				return false;
			}
			if (!item.m_customData.TryGetValue("ScrollPerk", out var value))
			{
				return false;
			}
			perk = ScrollPerkRegistry.GetByName(value);
			return perk != null;
		}
	}
	[HarmonyPatch(typeof(CharacterDrop), "OnDeath")]
	public static class ScrollOnDeathPatch
	{
		[HarmonyPostfix]
		public static void Postfix(CharacterDrop __instance)
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			string text = ((Object)((Component)__instance).gameObject).name.Replace("(Clone)", "").Trim();
			if (!ScrollItem.DropTable.TryGetValue(text, out (ItemRarity, float)[] value))
			{
				return;
			}
			(ItemRarity, float)[] array = value;
			for (int i = 0; i < array.Length; i++)
			{
				(ItemRarity, float) tuple = array[i];
				if (Random.value > tuple.Item2)
				{
					continue;
				}
				string text2 = ScrollItem.PrefabNames[tuple.Item1];
				GameObject prefab = ZNetScene.instance.GetPrefab(text2);
				if (!((Object)(object)prefab == (Object)null))
				{
					Vector3 val = ((Component)__instance).transform.position + Vector3.up * 0.5f;
					GameObject val2 = Object.Instantiate<GameObject>(prefab, val, Quaternion.identity);
					ItemDrop component = val2.GetComponent<ItemDrop>();
					if (component?.m_itemData != null)
					{
						ItemData itemData = component.m_itemData;
						Dictionary<string, string> customData = itemData.m_customData;
						int item = (int)tuple.Item1;
						customData["ScrollTier"] = item.ToString();
						Logger.LogInfo((object)("[ScrollDrop] " + text + " dropeó " + text2 + " [BLOQUEADO]"));
					}
				}
			}
		}
	}
	public enum ScrollPerkType
	{
		Pierce,
		Blunt,
		Slash,
		ReduccionDmg,
		Durabilidad,
		DmgFaccion,
		VelocidadAtk,
		DmgMagico,
		Vida,
		Armadura,
		RegHP,
		RegStamina,
		RegEitr,
		Healing,
		ResistPierce,
		ResistBlunt,
		ResistSlash,
		Bloqueo,
		Parry,
		NoMovPen,
		WeapSkill,
		Weight
	}
	public class ScrollPerkDef
	{
		public ScrollPerkType Type;

		public string DisplayName;

		public bool Stackable;

		public float Uncommon;

		public float Rare;

		public float Epic;

		public float Legendary;

		public float GetValue(ItemRarity rarity)
		{
			if (1 == 0)
			{
			}
			float result = rarity switch
			{
				ItemRarity.Uncommon => Uncommon, 
				ItemRarity.Rare => Rare, 
				ItemRarity.Epic => Epic, 
				ItemRarity.Legendary => Legendary, 
				_ => 0f, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public string GetDisplayText(ItemRarity rarity)
		{
			float value = GetValue(rarity);
			string text = ((Type == ScrollPerkType.Vida || Type == ScrollPerkType.Armadura || Type == ScrollPerkType.Durabilidad || Type == ScrollPerkType.WeapSkill || Type == ScrollPerkType.Weight || Type == ScrollPerkType.NoMovPen) ? $"+{value:0}" : $"+{value:0.##}%");
			if (Type == ScrollPerkType.NoMovPen)
			{
				text = "Activado";
			}
			ScrollPerkType type = Type;
			if (1 == 0)
			{
			}
			string text2 = type switch
			{
				ScrollPerkType.Pierce => "Dmg Perforante", 
				ScrollPerkType.Blunt => "Dmg Contundente", 
				ScrollPerkType.Slash => "Dmg Cortante", 
				ScrollPerkType.DmgMagico => "Dmg Mágico", 
				ScrollPerkType.VelocidadAtk => "Vel. Ataque", 
				ScrollPerkType.DmgFaccion => "Dmg a Facción", 
				ScrollPerkType.ReduccionDmg => "Reducción Daño", 
				ScrollPerkType.Armadura => "Armadura", 
				ScrollPerkType.Vida => "HP Máximo", 
				ScrollPerkType.RegHP => "Regen HP", 
				ScrollPerkType.RegStamina => "Regen Stamina", 
				ScrollPerkType.RegEitr => "Regen Eitr", 
				ScrollPerkType.Durabilidad => "Durabilidad", 
				ScrollPerkType.Healing => "Poder Curación", 
				ScrollPerkType.ResistPierce => "Resist. Perforante", 
				ScrollPerkType.ResistBlunt => "Resist. Contundente", 
				ScrollPerkType.ResistSlash => "Resist. Cortante", 
				ScrollPerkType.Bloqueo => "Bloqueo", 
				ScrollPerkType.Parry => "Parry", 
				ScrollPerkType.NoMovPen => "Sin Penalización Mov.", 
				ScrollPerkType.WeapSkill => "Skill de Arma", 
				ScrollPerkType.Weight => "Peso Máximo", 
				_ => DisplayName, 
			};
			if (1 == 0)
			{
			}
			string text3 = text2;
			return text + " " + text3;
		}
	}
	public static class ScrollPerkRegistry
	{
		public static readonly List<ScrollPerkDef> All = new List<ScrollPerkDef>
		{
			new ScrollPerkDef
			{
				Type = ScrollPerkType.Pierce,
				DisplayName = "Daño Punzante",
				Stackable = true,
				Uncommon = 2f,
				Rare = 4f,
				Epic = 7f,
				Legendary = 10f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.Blunt,
				DisplayName = "Daño Contundente",
				Stackable = true,
				Uncommon = 2f,
				Rare = 4f,
				Epic = 7f,
				Legendary = 10f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.Slash,
				DisplayName = "Daño Cortante",
				Stackable = true,
				Uncommon = 2f,
				Rare = 4f,
				Epic = 7f,
				Legendary = 10f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.DmgMagico,
				DisplayName = "Daño Magico",
				Stackable = true,
				Uncommon = 2f,
				Rare = 4f,
				Epic = 7f,
				Legendary = 10f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.VelocidadAtk,
				DisplayName = "Velocidad de Atk",
				Stackable = true,
				Uncommon = 3f,
				Rare = 5f,
				Epic = 7f,
				Legendary = 10f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.DmgFaccion,
				DisplayName = "Daño a Faccion",
				Stackable = false,
				Uncommon = 5f,
				Rare = 7f,
				Epic = 10f,
				Legendary = 15f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.ReduccionDmg,
				DisplayName = "Reduccion de Daño",
				Stackable = true,
				Uncommon = 1f,
				Rare = 2f,
				Epic = 3f,
				Legendary = 4f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.Armadura,
				DisplayName = "Armadura",
				Stackable = true,
				Uncommon = 2f,
				Rare = 3f,
				Epic = 5f,
				Legendary = 7f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.Vida,
				DisplayName = "Vida",
				Stackable = true,
				Uncommon = 3f,
				Rare = 5f,
				Epic = 7f,
				Legendary = 10f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.ResistPierce,
				DisplayName = "Proteccion Perforante",
				Stackable = true,
				Uncommon = 12.5f,
				Rare = 12.5f,
				Epic = 12.5f,
				Legendary = 12.5f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.ResistBlunt,
				DisplayName = "Proteccion Contundente",
				Stackable = true,
				Uncommon = 12.5f,
				Rare = 12.5f,
				Epic = 12.5f,
				Legendary = 12.5f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.ResistSlash,
				DisplayName = "Proteccion Cortante",
				Stackable = true,
				Uncommon = 12.5f,
				Rare = 12.5f,
				Epic = 12.5f,
				Legendary = 12.5f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.Bloqueo,
				DisplayName = "Aegis",
				Stackable = false,
				Uncommon = 1.25f,
				Rare = 2.5f,
				Epic = 3.75f,
				Legendary = 5f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.Parry,
				DisplayName = "Contraataque",
				Stackable = false,
				Uncommon = 0.75f,
				Rare = 1.5f,
				Epic = 2.25f,
				Legendary = 3f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.NoMovPen,
				DisplayName = "Sin Limites",
				Stackable = false,
				Uncommon = 1f,
				Rare = 1f,
				Epic = 1f,
				Legendary = 1f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.RegHP,
				DisplayName = "Regeneracion de HP",
				Stackable = true,
				Uncommon = 1f,
				Rare = 2f,
				Epic = 3f,
				Legendary = 4f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.RegStamina,
				DisplayName = "Regeneracion de Stamina",
				Stackable = true,
				Uncommon = 2f,
				Rare = 3f,
				Epic = 4f,
				Legendary = 5f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.RegEitr,
				DisplayName = "Regeneracion de Eitr",
				Stackable = true,
				Uncommon = 2f,
				Rare = 3f,
				Epic = 4f,
				Legendary = 5f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.Durabilidad,
				DisplayName = "Durabilidad",
				Stackable = false,
				Uncommon = 5f,
				Rare = 10f,
				Epic = 15f,
				Legendary = 20f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.Healing,
				DisplayName = "Healing",
				Stackable = true,
				Uncommon = 2f,
				Rare = 3f,
				Epic = 4f,
				Legendary = 5f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.WeapSkill,
				DisplayName = "Destreza",
				Stackable = false,
				Uncommon = 0.5f,
				Rare = 1f,
				Epic = 1.5f,
				Legendary = 2f
			},
			new ScrollPerkDef
			{
				Type = ScrollPerkType.Weight,
				DisplayName = "Sobrecarga",
				Stackable = true,
				Uncommon = 6.25f,
				Rare = 12.5f,
				Epic = 18.75f,
				Legendary = 25f
			}
		};

		public static ScrollPerkDef Get(ScrollPerkType type)
		{
			return All.Find((ScrollPerkDef p) => p.Type == type);
		}

		public static ScrollPerkDef GetByName(string displayName)
		{
			return All.Find((ScrollPerkDef p) => p.DisplayName == displayName);
		}
	}
	public class SE_EnchantBonus : StatusEffect
	{
		public static readonly int NameHashID = StringExtensionMethods.GetStableHashCode("SE_EnchantBonus");

		public float BonusReduccionDmg;

		public float BonusArmadura;

		public float BonusVida;

		public float BonusStamina;

		public float BonusEitr;

		public float BonusRegHP;

		public float BonusRegStamina;

		public float BonusRegEitr;

		public float BonusVelocidadAtk;

		public float BonusDurabilidad;

		public float BonusResistPierce;

		public float BonusResistBlunt;

		public float BonusResistSlash;

		public float BonusBloqueo;

		public float BonusParry;

		public bool HasNoMovPen;

		public float BonusWeapSkill;

		public float BonusWeight;

		public SkillType WeapSkillType = (SkillType)0;

		public override bool IsDone()
		{
			return false;
		}

		public override void ModifyArmorMods(ref float armor)
		{
			armor += BonusArmadura;
		}

		public override void ModifyHealthRegen(ref float regenMultiplier)
		{
			regenMultiplier += BonusRegHP / 100f;
		}

		public override void ModifyStaminaRegen(ref float staminaRegen)
		{
			staminaRegen *= 1f + BonusRegStamina / 100f;
		}

		public override void ModifyEitrRegen(ref float eitrRegen)
		{
			eitrRegen *= 1f + BonusRegEitr / 100f;
		}

		public override void ModifyMaxCarryWeight(float baseLimit, ref float limit)
		{
			limit += BonusWeight;
		}
	}
	[HarmonyPatch(typeof(Player), "GetBaseFoodHP")]
	public static class Player_GetBaseFoodHP_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(Player __instance, ref float __result)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				SEMan sEMan = ((Character)__instance).GetSEMan();
				SE_EnchantBonus sE_EnchantBonus = ((sEMan != null) ? sEMan.GetStatusEffect(SE_EnchantBonus.NameHashID) : null) as SE_EnchantBonus;
				if (!((Object)(object)sE_EnchantBonus == (Object)null) && !(sE_EnchantBonus.BonusVida <= 0f))
				{
					__result += sE_EnchantBonus.BonusVida;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "Awake")]
	public static class SE_EnchantBonus_Register
	{
		[HarmonyPostfix]
		public static void Postfix(ObjectDB __instance)
		{
			if (!((Object)(object)__instance.GetStatusEffect(SE_EnchantBonus.NameHashID) != (Object)null))
			{
				SE_EnchantBonus sE_EnchantBonus = ScriptableObject.CreateInstance<SE_EnchantBonus>();
				((Object)sE_EnchantBonus).name = "SE_EnchantBonus";
				((StatusEffect)sE_EnchantBonus).m_name = "Encantamiento";
				((StatusEffect)sE_EnchantBonus).m_ttl = 0f;
				((StatusEffect)sE_EnchantBonus).m_icon = null;
				__instance.m_StatusEffects.Add((StatusEffect)(object)sE_EnchantBonus);
				Logger.LogInfo((object)"[SE_EnchantBonus] Registrado en ObjectDB.");
				SE_VelocidadAtk_ASM.Register();
			}
		}
	}
	public static class SE_VelocidadAtk_ASM
	{
		private static bool _registered;

		public static void Register()
		{
			if (!_registered)
			{
				_registered = true;
				AnimationSpeedManager.Add(OnAnimationSpeed);
			}
		}

		private static double OnAnimationSpeed(Character character, double speed)
		{
			Player val = (Player)(object)((character is Player) ? character : null);
			if ((Object)(object)val == (Object)null)
			{
				return speed;
			}
			if (!((Character)val).InAttack() || ((Humanoid)val).m_currentAttack == null)
			{
				return speed;
			}
			ItemData weapon = ((Humanoid)val).m_currentAttack.m_weapon;
			if (weapon == null)
			{
				return speed;
			}
			RarityItemData rarityItemData = RarityTooltip.Get(weapon);
			if (rarityItemData == null || rarityItemData.InsertedScrollIds == null)
			{
				return speed;
			}
			float num = 0f;
			foreach (string insertedScrollId in rarityItemData.InsertedScrollIds)
			{
				if (!string.IsNullOrEmpty(insertedScrollId))
				{
					ScrollPerkDef byName = ScrollPerkRegistry.GetByName(insertedScrollId.Split(new char[1] { ':' })[0]);
					if (byName != null && byName.Type == ScrollPerkType.VelocidadAtk)
					{
						num += byName.GetValue(rarityItemData.Rarity);
					}
				}
			}
			if (num <= 0f)
			{
				return speed;
			}
			return speed * (1.0 + (double)num / 100.0);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "EquipItem")]
	public static class SE_EnchantBonus_OnEquip
	{
		[HarmonyPostfix]
		public static void Postfix(Humanoid __instance, bool __result)
		{
			if (__result)
			{
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val != null && (Object)(object)val == (Object)(object)Player.m_localPlayer)
				{
					EnchantBonusManager.Refresh(val);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
	public static class SE_EnchantBonus_OnUnequip
	{
		[HarmonyPostfix]
		public static void Postfix(Humanoid __instance)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if (val != null && (Object)(object)val == (Object)(object)Player.m_localPlayer)
			{
				EnchantBonusManager.Refresh(val);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "OnSpawned")]
	public static class SE_EnchantBonus_OnSpawn
	{
		[HarmonyPostfix]
		public static void Postfix(Player __instance)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				EnchantBonusManager.RefreshAllInventory(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Character), "Damage")]
	public static class SE_ReduccionDmg_Patch
	{
		[HarmonyPrefix]
		public static void Prefix(Character __instance, ref HitData hit)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			SEMan sEMan = ((Character)val).GetSEMan();
			SE_EnchantBonus sE_EnchantBonus = ((sEMan != null) ? sEMan.GetStatusEffect(SE_EnchantBonus.NameHashID) : null) as SE_EnchantBonus;
			if (!((Object)(object)sE_EnchantBonus == (Object)null))
			{
				if (sE_EnchantBonus.BonusReduccionDmg > 0f)
				{
					float num = 1f - sE_EnchantBonus.BonusReduccionDmg / 100f;
					hit.m_damage.m_blunt *= num;
					hit.m_damage.m_slash *= num;
					hit.m_damage.m_pierce *= num;
					hit.m_damage.m_fire *= num;
					hit.m_damage.m_frost *= num;
					hit.m_damage.m_lightning *= num;
					hit.m_damage.m_poison *= num;
					hit.m_damage.m_spirit *= num;
					hit.m_damage.m_chop *= num;
					hit.m_damage.m_pickaxe *= num;
				}
				if (sE_EnchantBonus.BonusResistPierce > 0f)
				{
					hit.m_damage.m_pierce *= 1f - sE_EnchantBonus.BonusResistPierce / 100f;
				}
				if (sE_EnchantBonus.BonusResistBlunt > 0f)
				{
					hit.m_damage.m_blunt *= 1f - sE_EnchantBonus.BonusResistBlunt / 100f;
				}
				if (sE_EnchantBonus.BonusResistSlash > 0f)
				{
					hit.m_damage.m_slash *= 1f - sE_EnchantBonus.BonusResistSlash / 100f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Character), "Damage")]
	public static class SE_DmgFaccion_Patch
	{
		[HarmonyPrefix]
		public static void Prefix(Character __instance, ref HitData hit)
		{
			//IL_0003: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			if (hit.m_attacker == ZDOID.None)
			{
				return;
			}
			Character attacker = hit.GetAttacker();
			Player val = (Player)(object)((attacker is Player) ? attacker : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			ItemData[] array = (ItemData[])(object)new ItemData[7]
			{
				((Humanoid)val).m_rightItem,
				((Humanoid)val).m_leftItem,
				((Humanoid)val).m_chestItem,
				((Humanoid)val).m_legItem,
				((Humanoid)val).m_helmetItem,
				((Humanoid)val).m_shoulderItem,
				((Humanoid)val).m_utilityItem
			};
			float num = 0f;
			ItemData[] array2 = array;
			foreach (ItemData val2 in array2)
			{
				if (val2 != null && EnchantBonusManager.TryGetFactionBonus(val2, out var faction, out var bonus) && __instance.GetFaction() == faction)
				{
					num += bonus;
				}
			}
			if (!(num <= 0f))
			{
				float num2 = 1f + num / 100f;
				hit.m_damage.m_blunt *= num2;
				hit.m_damage.m_slash *= num2;
				hit.m_damage.m_pierce *= num2;
				hit.m_damage.m_fire *= num2;
				hit.m_damage.m_frost *= num2;
				hit.m_damage.m_lightning *= num2;
				hit.m_damage.m_spirit *= num2;
			}
		}
	}
	[HarmonyPatch(typeof(ItemData), "GetBlockPower", new Type[]
	{
		typeof(int),
		typeof(float)
	})]
	public static class SE_Bloqueo_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(ItemData __instance, ref float __result)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (((Humanoid)localPlayer).m_leftItem != __instance && ((Humanoid)localPlayer).m_rightItem != __instance))
			{
				return;
			}
			RarityItemData rarityItemData = RarityTooltip.Get(__instance);
			if (rarityItemData == null)
			{
				return;
			}
			float num = 0f;
			foreach (string insertedScrollId in rarityItemData.InsertedScrollIds)
			{
				if (!string.IsNullOrEmpty(insertedScrollId))
				{
					ScrollPerkDef byName = ScrollPerkRegistry.GetByName(insertedScrollId.Split(new char[1] { ':' })[0]);
					if (byName != null && byName.Type == ScrollPerkType.Bloqueo)
					{
						num += byName.GetValue(rarityItemData.Rarity);
					}
				}
			}
			if (!(num <= 0f))
			{
				__result *= 1f + num / 100f;
			}
		}
	}
	public static class ParryBonusManager
	{
		private static readonly Dictionary<ItemData, float> _baseParry = new Dictionary<ItemData, float>();

		public static void ApplyParryBonus(ItemData item, float bonusPct)
		{
			if (item != null && !(bonusPct <= 0f))
			{
				if (!_baseParry.ContainsKey(item))
				{
					_baseParry[item] = item.m_shared.m_timedBlockBonus;
				}
				item.m_shared.m_timedBlockBonus = _baseParry[item] * (1f + bonusPct / 100f);
			}
		}

		public static void RestoreParryBonus(ItemData item)
		{
			if (item != null && _baseParry.TryGetValue(item, out var value))
			{
				item.m_shared.m_timedBlockBonus = value;
				_baseParry.Remove(item);
			}
		}

		public static void RestoreAll(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				ItemData[] array = (ItemData[])(object)new ItemData[7]
				{
					((Humanoid)player).m_rightItem,
					((Humanoid)player).m_leftItem,
					((Humanoid)player).m_chestItem,
					((Humanoid)player).m_legItem,
					((Humanoid)player).m_helmetItem,
					((Humanoid)player).m_shoulderItem,
					((Humanoid)player).m_utilityItem
				};
				foreach (ItemData item in array)
				{
					RestoreParryBonus(item);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "GetEquipmentMovementModifier")]
	public static class SE_NoMovPen_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(Player __instance, ref float __result)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				SEMan sEMan = ((Character)__instance).GetSEMan();
				SE_EnchantBonus sE_EnchantBonus = ((sEMan != null) ? sEMan.GetStatusEffect(SE_EnchantBonus.NameHashID) : null) as SE_EnchantBonus;
				if (!((Object)(object)sE_EnchantBonus == (Object)null) && sE_EnchantBonus.HasNoMovPen && __result < 0f)
				{
					__result = 0f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Skills), "GetSkillLevel")]
	public static class SE_WeapSkill_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(Skills __instance, SkillType skillType, ref float __result)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Invalid comparison between Unknown and I4
			//IL_007c: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer.m_skills != (Object)(object)__instance)
			{
				return;
			}
			SEMan sEMan = ((Character)localPlayer).GetSEMan();
			SE_EnchantBonus sE_EnchantBonus = ((sEMan != null) ? sEMan.GetStatusEffect(SE_EnchantBonus.NameHashID) : null) as SE_EnchantBonus;
			if (!((Object)(object)sE_EnchantBonus == (Object)null) && !(sE_EnchantBonus.BonusWeapSkill <= 0f) && (int)sE_EnchantBonus.WeapSkillType != 0 && skillType == sE_EnchantBonus.WeapSkillType)
			{
				float num = __instance.GetSkill(skillType)?.m_level ?? 0f;
				if (__result < num + sE_EnchantBonus.BonusWeapSkill)
				{
					__result = num + sE_EnchantBonus.BonusWeapSkill;
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemData), "GetMaxDurability", new Type[] { })]
	public static class SE_Durabilidad_Patch
	{
		[HarmonyPostfix]
		public static void Postfix(ItemData __instance, ref float __result)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			ItemData[] array = (ItemData[])(object)new ItemData[7]
			{
				((Humanoid)localPlayer).m_rightItem,
				((Humanoid)localPlayer).m_leftItem,
				((Humanoid)localPlayer).m_chestItem,
				((Humanoid)localPlayer).m_legItem,
				((Humanoid)localPlayer).m_helmetItem,
				((Humanoid)localPlayer).m_shoulderItem,
				((Humanoid)localPlayer).m_utilityItem
			};
			bool flag = false;
			ItemData[] array2 = array;
			foreach (ItemData val in array2)
			{
				if (val == __instance)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				return;
			}
			RarityItemData rarityItemData = RarityTooltip.Get(__instance);
			if (rarityItemData == null)
			{
				return;
			}
			foreach (string insertedScrollId in rarityItemData.InsertedScrollIds)
			{
				if (!string.IsNullOrEmpty(insertedScrollId))
				{
					ScrollPerkDef byName = ScrollPerkRegistry.GetByName(insertedScrollId);
					if (byName != null && byName.Type == ScrollPerkType.Durabilidad)
					{
						__result += byName.GetValue(rarityItemData.Rarity);
					}
				}
			}
		}
	}
	public static class EnchantBonusManager
	{
		private static float _originalBaseHP = -1f;

		private static float _originalBaseStamina = -1f;

		private static bool _refreshing = false;

		public static bool TryGetFactionBonus(ItemData item, out Faction faction, out float bonus)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected I4, but got Unknown
			faction = (Faction)2;
			bonus = 0f;
			RarityItemData rarityItemData = RarityTooltip.Get(item);
			if (rarityItemData == null)
			{
				return false;
			}
			foreach (string insertedScrollId in rarityItemData.InsertedScrollIds)
			{
				if (string.IsNullOrEmpty(insertedScrollId))
				{
					continue;
				}
				string[] array = insertedScrollId.Split(new char[1] { ':' });
				if (array.Length == 2)
				{
					ScrollPerkDef byName = ScrollPerkRegistry.GetByName(array[0]);
					if (byName != null && byName.Type == ScrollPerkType.DmgFaccion && Enum.TryParse<Faction>(array[1], out Faction result))
					{
						faction = (Faction)(int)result;
						bonus = byName.GetValue(rarityItemData.Rarity);
						return true;
					}
				}
			}
			return false;
		}

		public static void Refresh(Player player)
		{
			if (_refreshing || (Object)(object)player == (Object)null || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return;
			}
			_refreshing = true;
			try
			{
				RefreshInternal(player);
			}
			finally
			{
				_refreshing = false;
			}
		}

		public static void RefreshAllInventory(Player player)
		{
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return;
			}
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if (!RarityPatches.IsWeaponOrArmor(allItem))
				{
					continue;
				}
				RarityItemData rarityItemData = RarityTooltip.Get(allItem);
				if (rarityItemData == null || rarityItemData.Rarity == ItemRarity.Common)
				{
					continue;
				}
				if (rarityItemData.HasBaseDamages)
				{
					rarityItemData.RestoreBaseDamages(allItem);
					RarityPatches.ApplyStatBonusToDamages(allItem, rarityItemData);
				}
				RarityPatches.ApplyStatBonusToArmor(allItem, rarityItemData);
				RarityPatches.ApplyStatBonusToBlockPower(allItem, rarityItemData);
				float num = 0f;
				float num2 = 0f;
				float num3 = 0f;
				float num4 = 0f;
				foreach (string insertedScrollId in rarityItemData.InsertedScrollIds)
				{
					if (string.IsNullOrEmpty(insertedScrollId))
					{
						continue;
					}
					ScrollPerkDef byName = ScrollPerkRegistry.GetByName(insertedScrollId.Split(new char[1] { ':' })[0]);
					if (byName != null)
					{
						float value = byName.GetValue(rarityItemData.Rarity);
						switch (byName.Type)
						{
						case ScrollPerkType.Pierce:
							num += value;
							break;
						case ScrollPerkType.Blunt:
							num2 += value;
							break;
						case ScrollPerkType.Slash:
							num3 += value;
							break;
						case ScrollPerkType.DmgMagico:
							num4 += value;
							break;
						}
					}
				}
				if (rarityItemData.HasBaseDamages && (num > 0f || num2 > 0f || num3 > 0f || num4 > 0f))
				{
					DamageTypes damages = allItem.m_shared.m_damages;
					if (num > 0f)
					{
						damages.m_pierce *= 1f + num / 100f;
					}
					if (num2 > 0f)
					{
						damages.m_blunt *= 1f + num2 / 100f;
					}
					if (num3 > 0f)
					{
						damages.m_slash *= 1f + num3 / 100f;
					}
					if (num4 > 0f)
					{
						damages.m_fire *= 1f + num4 / 100f;
						damages.m_frost *= 1f + num4 / 100f;
						damages.m_lightning *= 1f + num4 / 100f;
						damages.m_spirit *= 1f + num4 / 100f;
						damages.m_poison *= 1f + num4 / 100f;
					}
					allItem.m_shared.m_damages = damages;
				}
				Logger.LogInfo((object)($"[RefreshAllInventory] {allItem.m_shared.m_name} q={allItem.m_quality} " + $"m_armor={allItem.m_shared.m_armor:0.##}"));
			}
			Refresh(player);
		}

		public static void RefreshSingleItem(ItemData item)
		{
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			if (item == null)
			{
				return;
			}
			RarityItemData rarityItemData = RarityTooltip.Get(item);
			if (rarityItemData == null)
			{
				return;
			}
			if (rarityItemData.HasBaseDamages)
			{
				rarityItemData.RestoreBaseDamages(item);
				RarityPatches.ApplyStatBonusToDamages(item, rarityItemData);
			}
			RarityPatches.ApplyStatBonusToArmor(item, rarityItemData);
			RarityPatches.ApplyStatBonusToBlockPower(item, rarityItemData);
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			foreach (string insertedScrollId in rarityItemData.InsertedScrollIds)
			{
				if (string.IsNullOrEmpty(insertedScrollId))
				{
					continue;
				}
				string displayName = insertedScrollId.Split(new char[1] { ':' })[0];
				ScrollPerkDef byName = ScrollPerkRegistry.GetByName(displayName);
				if (byName != null)
				{
					float value = byName.GetValue(rarityItemData.Rarity);
					switch (byName.Type)
					{
					case ScrollPerkType.Pierce:
						num += value;
						break;
					case ScrollPerkType.Blunt:
						num2 += value;
						break;
					case ScrollPerkType.Slash:
						num3 += value;
						break;
					case ScrollPerkType.DmgMagico:
						num4 += value;
						break;
					}
				}
			}
			if (rarityItemData.HasBaseDamages && (num > 0f || num2 > 0f || num3 > 0f || num4 > 0f))
			{
				DamageTypes damages = item.m_shared.m_damages;
				if (num > 0f)
				{
					damages.m_pierce *= 1f + num / 100f;
				}
				if (num2 > 0f)
				{
					damages.m_blunt *= 1f + num2 / 100f;
				}
				if (num3 > 0f)
				{
					damages.m_slash *= 1f + num3 / 100f;
				}
				if (num4 > 0f)
				{
					damages.m_fire *= 1f + num4 / 100f;
					damages.m_frost *= 1f + num4 / 100f;
					damages.m_lightning *= 1f + num4 / 100f;
					damages.m_spirit *= 1f + num4 / 100f;
					damages.m_poison *= 1f + num4 / 100f;
				}
				item.m_shared.m_damages = damages;
			}
			Logger.LogInfo((object)("[RefreshSingleItem] " + item.m_shared?.m_name + " " + $"blockPower={item.m_shared.m_blockPower:0.#} " + $"pierce={item.m_shared.m_damages.m_pierce:0.#} " + $"slash={item.m_shared.m_damages.m_slash:0.#} " + $"blunt={item.m_shared.m_damages.m_blunt:0.#}"));
		}

		private static SkillType GetWeaponSkillType(ItemData item)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_0039: Invalid comparison between Unknown and I4
			//IL_0044: 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_003f: Invalid comparison between Unknown and I4
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (item == null)
			{
				return (SkillType)0;
			}
			ItemType itemType = item.m_shared.m_itemType;
			SkillType skillType = item.m_shared.m_skillType;
			if ((int)skillType > 0)
			{
				return skillType;
			}
			if (1 == 0)
			{
			}
			SkillType result = (((int)itemType == 4) ? ((SkillType)8) : (((int)itemType != 5) ? ((SkillType)0) : ((SkillType)6)));
			if (1 == 0)
			{
			}
			return result;
		}

		private static void RefreshInternal(Player player)
		{
			//IL_0487: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Invalid comparison between Unknown and I4
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Unknown result type (might be due to invalid IL or missing references)
			//IL_050d: Unknown result type (might be due to invalid IL or missing references)
			//IL_061c: Unknown result type (might be due to invalid IL or missing references)
			//IL_061e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return;
			}
			ParryBonusManager.RestoreAll(player);
			if (_originalBaseHP < 0f)
			{
				_originalBaseHP = player.m_baseHP;
			}
			if (_originalBaseStamina < 0f)
			{
				_originalBaseStamina = player.m_baseStamina;
			}
			player.m_baseHP = _originalBaseHP;
			player.m_baseStamina = _originalBaseStamina;
			SEMan sEMan = ((Character)player).GetSEMan();
			if (sEMan == null)
			{
				return;
			}
			sEMan.RemoveStatusEffect(SE_EnchantBonus.NameHashID, false);
			SE_EnchantBonus sE_EnchantBonus = ObjectDB.instance.GetStatusEffect(SE_EnchantBonus.NameHashID) as SE_EnchantBonus;
			if ((Object)(object)sE_EnchantBonus == (Object)null)
			{
				return;
			}
			SE_EnchantBonus sE_EnchantBonus2 = ((StatusEffect)sE_EnchantBonus).Clone() as SE_EnchantBonus;
			if ((Object)(object)sE_EnchantBonus2 == (Object)null)
			{
				return;
			}
			List<ItemData> list = new List<ItemData>();
			if (((Humanoid)player).m_rightItem != null)
			{
				list.Add(((Humanoid)player).m_rightItem);
			}
			if (((Humanoid)player).m_leftItem != null)
			{
				list.Add(((Humanoid)player).m_leftItem);
			}
			if (((Humanoid)player).m_chestItem != null)
			{
				list.Add(((Humanoid)player).m_chestItem);
			}
			if (((Humanoid)player).m_legItem != null)
			{
				list.Add(((Humanoid)player).m_legItem);
			}
			if (((Humanoid)player).m_helmetItem != null)
			{
				list.Add(((Humanoid)player).m_helmetItem);
			}
			if (((Humanoid)player).m_shoulderItem != null)
			{
				list.Add(((Humanoid)player).m_shoulderItem);
			}
			if (((Humanoid)player).m_utilityItem != null)
			{
				list.Add(((Humanoid)player).m_utilityItem);
			}
			foreach (ItemData item in list)
			{
				RarityItemData rarityItemData = RarityTooltip.Get(item);
				if (rarityItemData == null)
				{
					continue;
				}
				Logger.LogInfo((object)("[Refresh] Item: " + item.m_shared?.m_name + " | Slots: " + string.Join(",", rarityItemData.InsertedScrollIds)));
				if (rarityItemData.HasBaseDamages)
				{
					rarityItemData.RestoreBaseDamages(item);
					RarityPatches.ApplyStatBonusToDamages(item, rarityItemData);
				}
				float num = 0f;
				float num2 = 0f;
				float num3 = 0f;
				float num4 = 0f;
				foreach (string insertedScrollId in rarityItemData.InsertedScrollIds)
				{
					if (string.IsNullOrEmpty(insertedScrollId))
					{
						continue;
					}
					string displayName = insertedScrollId.Split(new char[1] { ':' })[0];
					ScrollPerkDef byName = ScrollPerkRegistry.GetByName(displayName);
					if (byName == null)
					{
						continue;
					}
					float value = byName.GetValue(rarityItemData.Rarity);
					switch (byName.Type)
					{
					case ScrollPerkType.Pierce:
						num += value;
						break;
					case ScrollPerkType.Blunt:
						num2 += value;
						break;
					case ScrollPerkType.Slash:
						num3 += value;
						break;
					case ScrollPerkType.DmgMagico:
						num4 += value;
						break;
					case ScrollPerkType.ReduccionDmg:
						sE_EnchantBonus2.BonusReduccionDmg += value;
						break;
					case ScrollPerkType.Armadura:
						sE_EnchantBonus2.BonusArmadura += value;
						break;
					case ScrollPerkType.Vida:
						sE_EnchantBonus2.BonusVida += value;
						break;
					case ScrollPerkType.RegHP:
						sE_EnchantBonus2.BonusRegHP += value;
						break;
					case ScrollPerkType.RegStamina:
						sE_EnchantBonus2.BonusRegStamina += value;
						break;
					case ScrollPerkType.RegEitr:
						sE_EnchantBonus2.BonusRegEitr += value;
						break;
					case ScrollPerkType.VelocidadAtk:
						sE_EnchantBonus2.BonusVelocidadAtk += value;
						break;
					case ScrollPerkType.Durabilidad:
						sE_EnchantBonus2.BonusDurabilidad += value;
						break;
					case ScrollPerkType.ResistPierce:
						sE_EnchantBonus2.BonusResistPierce += value;
						break;
					case ScrollPerkType.ResistBlunt:
						sE_EnchantBonus2.BonusResistBlunt += value;
						break;
					case ScrollPerkType.ResistSlash:
						sE_EnchantBonus2.BonusResistSlash += value;
						break;
					case ScrollPerkType.Bloqueo:
						sE_EnchantBonus2.BonusBloqueo += value;
						break;
					case ScrollPerkType.Parry:
						sE_EnchantBonus2.BonusParry += value;
						break;
					case ScrollPerkType.NoMovPen:
						sE_EnchantBonus2.HasNoMovPen = true;
						break;
					case ScrollPerkType.Weight:
						sE_EnchantBonus2.BonusWeight += value;
						break;
					case ScrollPerkType.WeapSkill:
						sE_EnchantBonus2.BonusWeapSkill += value;
						if ((int)sE_EnchantBonus2.WeapSkillType == 0)
						{
							sE_EnchantBonus2.WeapSkillType = GetWeaponSkillType(item);
						}
						break;
					}
				}
				if (rarityItemData.HasBaseDamages && (num > 0f || num2 > 0f || num3 > 0f || num4 > 0f))
				{
					DamageTypes damages = item.m_shared.m_damages;
					if (num > 0f)
					{
						damages.m_pierce *= 1f + num / 100f;
					}
					if (num2 > 0f)
					{
						damages.m_blunt *= 1f + num2 / 100f;
					}
					if (num3 > 0f)
					{
						damages.m_slash *= 1f + num3 / 100f;
					}
					if (num4 > 0f)
					{
						damages.m_fire *= 1f + num4 / 100f;
						damages.m_frost *= 1f + num4 / 100f;
						damages.m_lightning *= 1f + num4 / 100f;
						damages.m_spirit *= 1f + num4 / 100f;
						damages.m_poison *= 1f + num4 / 100f;
					}
					item.m_shared.m_damages = damages;
				}
			}
			if (sE_EnchantBonus2.BonusVida > 0f)
			{
				player.m_baseHP = _originalBaseHP + sE_EnchantBonus2.BonusVida;
			}
			if (sE_EnchantBonus2.BonusParry > 0f)
			{
				if (((Humanoid)player).m_leftItem != null)
				{
					ParryBonusManager.ApplyParryBonus(((Humanoid)player).m_leftItem, sE_EnchantBonus2.BonusParry);
				}
				if (((Humanoid)player).m_rightItem != null)
				{
					ParryBonusManager.ApplyParryBonus(((Humanoid)player).m_rightItem, sE_EnchantBonus2.BonusParry);
				}
			}
			if (sE_EnchantBonus2.BonusReduccionDmg > 0f || sE_EnchantBonus2.BonusArmadura > 0f || sE_EnchantBonus2.BonusVida > 0f || sE_EnchantBonus2.BonusStamina > 0f || sE_EnchantBonus2.BonusEitr > 0f || sE_EnchantBonus2.BonusRegHP > 0f || sE_EnchantBonus2.BonusRegStamina > 0f || sE_EnchantBonus2.BonusRegEitr > 0f || sE_EnchantBonus2.BonusVelocidadAtk > 0f || sE_EnchantBonus2.BonusDurabilidad > 0f || sE_EnchantBonus2.BonusResistPierce > 0f || sE_EnchantBonus2.BonusResistBlunt > 0f || sE_EnchantBonus2.BonusResistSlash > 0f || sE_EnchantBonus2.BonusBloqueo > 0f || sE_EnchantBonus2.BonusParry > 0f || sE_EnchantBonus2.HasNoMovPen || sE_EnchantBonus2.BonusWeapSkill > 0f || sE_EnchantBonus2.BonusWeight > 0f || list.Exists((ItemData i) => RarityTooltip.Get(i)?.InsertedScrollIds.Exists((string s) => !string.IsNullOrEmpty(s) && s.StartsWith("Daño a Faccion:")) ?? false))
			{
				sEMan.AddStatusEffect((StatusEffect)(object)sE_EnchantBonus2, false, 0, 0f);
				player.UpdateFood(0f, true);
				Logger.LogInfo((object)"[SE_EnchantBonus] ── Bonuses aplicados ──────────────────");
				if (sE_EnchantBonus2.BonusReduccionDmg > 0f)
				{
					Logger.LogInfo((object)$"  Reduccion Daño:       -{sE_EnchantBonus2.BonusReduccionDmg}%");
				}
				if (sE_EnchantBonus2.BonusArmadura > 0f)
				{
					Logger.LogInfo((object)$"  Armadura:             +{sE_EnchantBonus2.BonusArmadura}");
				}
				if (sE_EnchantBonus2.BonusVida > 0f)
				{
					Logger.LogInfo((object)$"  Vida:                 +{sE_EnchantBonus2.BonusVida}");
				}
				if (sE_EnchantBonus2.BonusRegHP > 0f)
				{
					Logger.LogInfo((object)$"  Regen HP:             +{sE_EnchantBonus2.BonusRegHP}%");
				}
				if (sE_EnchantBonus2.BonusRegStamina > 0f)
				{
					Logger.LogInfo((object)$"  Regen Stamina:        +{sE_EnchantBonus2.BonusRegStamina}%");
				}
				if (sE_EnchantBonus2.BonusRegEitr > 0f)
				{
					Logger.LogInfo((object)$"  Regen Eitr:           +{sE_EnchantBonus2.BonusRegEitr}%");
				}
				if (sE_EnchantBonus2.BonusVelocidadAtk > 0f)
				{
					Logger.LogInfo((object)$"  Velocidad Atk:        +{sE_EnchantBonus2.BonusVelocidadAtk}%");
				}
				if (sE_EnchantBonus2.BonusDurabilidad > 0f)
				{
					Logger.LogInfo((object)$"  Durabilidad:          +{sE_EnchantBonus2.BonusDurabilidad}");
				}
				if (sE_EnchantBonus2.BonusResistPierce > 0f)
				{
					Logger.LogInfo((object)$"  Resist Perforante:    -{sE_EnchantBonus2.BonusResistPierce}%");
				}
				if (sE_EnchantBonus2.BonusResistBlunt > 0f)
				{
					Logger.LogInfo((object)$"  Resist Contundente:   -{sE_EnchantBonus2.BonusResistBlunt}%");
				}
				if (sE_EnchantBonus2.BonusResistSlash > 0f)
				{
					Logger.LogInfo((object)$"  Resist Cortante:      -{sE_EnchantBonus2.BonusResistSlash}%");
				}
				if (sE_EnchantBonus2.BonusBloqueo > 0f)
				{
					Logger.LogInfo((object)$"  Bloqueo:              +{sE_EnchantBonus2.BonusBloqueo}%");
				}
				if (sE_EnchantBonus2.BonusParry > 0f)
				{
					Logger.LogInfo((object)$"  Parry:                +{sE_EnchantBonus2.BonusParry}%");
				}
				if (sE_EnchantBonus2.HasNoMovPen)
				{
					Logger.LogInfo((object)"  Sin Penalización Mov: activo");
				}
				if (sE_EnchantBonus2.BonusWeapSkill > 0f)
				{
					Logger.LogInfo((object)$"  WeapSkill ({sE_EnchantBonus2.WeapSkillType}): +{sE_EnchantBonus2.BonusWeapSkill}");
				}
				if (sE_EnchantBonus2.BonusWeight > 0f)
				{
					Logger.LogInfo((object)$"  Peso Máximo:          +{sE_EnchantBonus2.BonusWeight}");
				}
				Logger.LogInfo((object)"[SE_EnchantBonus] ─────────────────────────────────────");
			}
			else
			{
				player.UpdateFood(0f, true);
				Logger.LogInfo((object)"[SE_EnchantBonus] Sin bonuses activos.");
			}
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
	public static class UpgradeDebug_DoCrafting
	{
		[HarmonyPrefix]
		public static void Prefix(InventoryGui __instance, Player player)
		{
			Recipe recipe = __instance.m_craftRecipe;
			if ((Object)(object)recipe == (Object)null)
			{
				return;
			}
			object obj;
			if (player == null)
			{
				obj = null;
			}
			else
			{
				Inventory inventory = ((Humanoid)player).GetInventory();
				obj = ((inventory == null) ? null : inventory.GetAllItems()?.Find((ItemData i) => i.m_shared?.m_name == recipe.m_item?.m_itemData?.m_shared?.m_name));
			}
			ItemData val = (ItemData)obj;
			if (val != null)
			{
				Logger.LogInfo((object)$"[UpgradeDebug] DoCrafting PREFIX — {val.m_shared.m_name} | quality={val.m_quality}");
			}
			else
			{
				Logger.LogInfo((object)"[UpgradeDebug] DoCrafting PREFIX — item no encontrado en inventario (es crafteo nuevo)");
			}
		}

		[HarmonyPostfix]
		public static void Postfix(InventoryGui __instance, Player player)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo((object)"[UpgradeDebug] DoCrafting POSTFIX — revisando inventario...");
			Inventory val = ((player != null) ? ((Humanoid)player).GetInventory() : null);
			if (val == null)
			{
				return;
			}
			foreach (ItemData allItem in val.GetAllItems())
			{
				if (RarityPatches.IsWeaponOrArmor(allItem))
				{
					RarityItemData rarityItemData = RarityTooltip.Get(allItem);
					if (rarityItemData != null)
					{
						DamageTypes damages = allItem.m_shared.m_damages;
						Logger.LogInfo((object)($"[UpgradeDebug]   {allItem.m_shared.m_name} q={allItem.m_quality} " + $"| m_pierce={damages.m_pierce:0.##} BasePierce={rarityItemData.BasePierce:0.##} " + $"| m_armor={allItem.m_shared.m_armor:0.##} BaseArmor={rarityItemData.BaseArmor:0.##}"));
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(Inventory), "AddItem", new Type[]
	{
		typeof(string),
		typeof(int),
		typeof(int),
		typeof(int),
		typeof(long),
		typeof(string),
		typeof(Vector2i),
		typeof(bool)
	})]
	public static class UpgradeDebug_AddItem
	{
		[HarmonyPostfix]
		public static void Postfix(ref ItemData __result)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (__result != null && RarityPatches.IsWeaponOrArmor(__result))
			{
				DamageTypes damages = __result.m_shared.m_damages;
				RarityItemData rarityItemData = RarityTooltip.Get(__result);
				Logger.LogInfo((object)($"[UpgradeDebug] AddItem — {__result.m_shared.m_name} q={__result.m_quality} " + $"| m_pierce={damages.m_pierce:0.##} m_slash={damages.m_slash:0.##} m_blunt={damages.m_blunt:0.##} " + $"| m_armor={__result.m_shared.m_armor:0.##} " + $"| hasRarityData={rarityItemData != null}"));
				if (rarityItemData != null)
				{
					Logger.LogInfo((object)($"[UpgradeDebug] AddItem — BasePierce={rarityItemData.BasePierce:0.##} BaseSlash={rarityItemData.BaseSlash:0.##} " + $"BaseBlunt={rarityItemData.BaseBlunt:0.##} BaseArmor={rarityItemData.BaseArmor:0.##}"));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Inventory), "RemoveItem", new Type[] { typeof(ItemData) })]
	public static class UpgradeDebug_RemoveItem
	{
		[HarmonyPrefix]
		public static void Prefix(ItemData item)
		{
			if (item != null && RarityPatches.IsWeaponOrArmor(item))
			{
				RarityItemData rarityItemData = RarityTooltip.Get(item);
				if (rarityItemData != null)
				{
					Logger.LogInfo((object)($"[UpgradeDebug] RemoveItem — {item.m_shared.m_name} q={item.m_quality} " + $"| hasRarityData=true | Rarity={rarityItemData.Rarity}"));
				}
			}
		}
	}
}
namespace NazhiMods.FishingTracker
{
	[HarmonyPatch(typeof(FishingFloat), "Setup")]
	public static class FishingFloat_Setup_Patch
	{
		private static void Postfix(FishingFloat __instance, Character owner, Vector3 velocity, float hitNoise, HitData hitData, ItemData item, ItemData ammo)
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)FishingTracker.Instance == (Object)null) && !((Object)(object)owner == (Object)null))
			{
				Player val = (Player)(object)((owner is Player) ? owner : null);
				if (!((Object)(object)val == (Object)null))
				{
					string text = (((Object)(object)ammo?.m_dropPrefab != (Object)null) ? ((Object)ammo.m_dropPrefab).name : "");
					string text2 = ammo?.m_shared?.m_name ?? "";
					FishingTracker.FishingEvent ev = new FishingTracker.FishingEvent
					{
						Timestamp = DateTime.Now,
						EventType = "Cast",
						PlayerName = val.GetPlayerName(),
						Biome = FishingTracker.GetPlayerBiome(val),
						Position = ((Component)val).transform.position,
						ItemPrefab = (((Object)(object)item?.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : ""),
						ItemName = (item?.m_shared?.m_name ?? ""),
						ItemQuality = (item?.m_quality ?? 0),
						ItemAmount = 1,
						Notes = "FishingFloat.Setup | baitPrefab=" + text + " baitName=" + text2
					};
					FishingTracker.Instance.RegisterEvent(ev);
				}
			}
		}
	}
	[HarmonyPatch(typeof(FishingFloat), "TryToHook")]
	public static class FishingFloat_TryToHook_TugOfWar_Patch
	{
		private static bool Prefix(FishingFloat __instance)
		{
			if (FishingTugOfWarMiniGame.IsActiveFor(__instance))
			{
				return false;
			}
			if ((Object)(object)__instance.m_nibbler == (Object)null)
			{
				return true;
			}
			if (Time.time - __instance.m_nibbleTime >= 0.5f)
			{
				return true;
			}
			if ((Object)(object)__instance.GetCatch() != (Object)null)
			{
				return true;
			}
			Character owner = __instance.GetOwner();
			Player val = (Player)(object)((owner is Player) ? owner : null);
			if (val == null)
			{
				return true;
			}
			if ((Object)(object)Player.m_localPlayer != (Object)(object)val)
			{
				return true;
			}
			Fish nibbler = __instance.m_nibbler;
			if ((Object)(object)nibbler == (Object)null)
			{
				return true;
			}
			FishingTugOfWarMiniGame.Start(__instance, val, nibbler);
			return false;
		}
	}
	[HarmonyPatch(typeof(FishingFloat), "FixedUpdate")]
	public static class FishingFloat_FixedUpdate_BlockPull_Patch
	{
		private static bool Prefix(FishingFloat __instance)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			if (!FishingTugOfWarMiniGame.IsActiveFor(__instance))
			{
				return true;
			}
			if (!__instance.m_nview.IsOwner())
			{
				return false;
			}
			Character owner = __instance.GetOwner();
			if (!Object.op_Implicit((Object)(object)owner))
			{
				ZLog.LogWarning((object)"Fishing rod not found, destroying fishing float");
				__instance.m_nview.Destroy();
				FishingTugOfWarMiniGame.Cancel("owner null in FixedUpdate");
				return false;
			}
			Transform rodTop = __instance.GetRodTop(owner);
			if (!Object.op_Implicit((Object)(object)rodTop))
			{
				ZLog.LogWarning((object)"Fishing rod not found, destroying fishing float");
				__instance.m_nview.Destroy();
				FishingTugOfWarMiniGame.Cancel("rodTop null in FixedUpdate");
				return false;
			}
			Vector3 val = ((Component)rodTop).transform.position - ((Component)__instance).transform.position;
			float magnitude = ((Vector3)(ref val)).magnitude;
			__instance.m_rodLine.SetSlack((1f - Utils.LerpStep(__instance.m_lineLength / 2f, __instance.m_lineLength, magnitude)) * __instance.m_maxLineSlack);
			if (magnitude - __instance.m_lineLength > __instance.m_breakDistance || magnitude > __instance.m_maxDistance)
			{
				__instance.Message("$msg_fishing_linebroke", true);
				Fish @catch = __instance.GetCatch();
				if (Object.op_Implicit((Object)(object)@catch))
				{
					@catch.OnHooked((FishingFloat)null);
				}
				__instance.m_nview.Destroy();
				__instance.m_lineBreakEffect.Create(((Component)__instance).transform.position, Quaternion.identity, (Transform)null, 1f, -1);
				FishingTugOfWarMiniGame.Fail("line break");
				return false;
			}
			Utils.Pull(__instance.m_body, ((Component)rodTop).transform.position, __instance.m_lineLength, __instance.m_moveForce, 1f, 0.3f, false, false, 1f);
			return false;
		}
	}
	[HarmonyPatch(typeof(FishingFloat), "OnDestroy")]
	public static class FishingFloat_OnDestroy_TugOfWar_Patch
	{
		private static void Postfix(FishingFloat __instance)
		{
			FishingTugOfWarMiniGame.NotifyFloatDestroyed(__instance);
		}
	}
	[BepInPlugin("nazhi.fishingtracker", "Fishing Tracker", "3.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class FishingTracker : BaseUnityPlugin
	{
		public class FishingEvent
		{
			public DateTime Timestamp;

			public string EventType;

			public string PlayerName;

			public string Biome;

			public Vector3 Position;

			public string ItemPrefab;

			public string ItemName;

			public int ItemQuality;

			public int ItemAmount;

			public string Notes;
		}

		private class FishLogCommand : ConsoleCommand
		{
			public override string Name => "fishlog";

			public override string Help => "fishlog [N] - Muestra los últimos N eventos de pesca (por defecto 20).";

			public override void Run(string[] args)
			{
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Instance == (Object)null)
				{
					Logger.LogWarning((object)"[FishingTracker] Instance es null.");
					return;
				}
				int num = 20;
				if (args.Length != 0 && int.TryParse(args[0], out var result))
				{
					num = Mathf.Clamp(result, 1, 200);
				}
				IReadOnlyList<FishingEvent> events = Instance.Events;
				if (events.Count == 0)
				{
					Logger.LogInfo((object)"[FishingTracker] No hay eventos registrados todavía.");
					return;
				}
				List<FishingEvent> list = events.Skip(Mathf.Max(0, events.Count - num)).ToList();
				Logger.LogInfo((object)$"[FishingTracker] Mostrando los últimos {list.Count} eventos:");
				foreach (FishingEvent item in list)
				{
					Logger.LogInfo((object)($"{item.Timestamp:HH:mm:ss} {item.EventType} | " + $"Player={item.PlayerName} | Biome={item.Biome} | Pos={item.Position} | " + $"Item={item.ItemPrefab}/{item.ItemName} x{item.ItemAmount} q{item.ItemQuality} | {item.Notes}"));
				}
			}
		}

		public const string ModGuid = "nazhi.fishingtracker";

		public const string ModName = "Fishing Tracker";

		public const string ModVersion = "3.0.0";

		internal static FishingTracker Instance;

		internal static ManualLogSource Log;

		private Harmony _harmony;

		private ConfigEntry<bool> _enableConsoleLogging;

		private ConfigEntry<int> _maxMemoryEvents;

		internal static ConfigEntry<float> FishIconSizeConfig;

		private readonly List<FishingEvent> _events = new List<FishingEvent>();

		public IReadOnlyList<FishingEvent> Events => _events;

		private void Awake()
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			_enableConsoleLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableConsoleLogging", true, "Muestra cada evento de pesca en el log de BepInEx.");
			_maxMemoryEvents = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MaxMemoryEvents", 500, "Máximo de eventos guardados en memoria para el comando fishlog.");
			FishIconSizeConfig = ((BaseUnityPlugin)this).Config.Bind<float>("UI", "FishIconSize", 72f, "Altura del icono de pez (en píxeles) en el minijuego de tira y afloja.");
			_harmony = new Harmony("nazhi.fishingtracker");
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			TryRegisterConsoleCommands();
			FishingTugOfWarMiniGame.EnsureUI();
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)"Fishing Tracker 3.0.0 inicializado. Tracker + minijuego tira y afloja con durabilidad \ud83d\ude0e");
			}
		}

		private void OnDestroy()
		{
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		public void RegisterEvent(FishingEvent ev)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			_events.Add(ev);
			while (_events.Count > _maxMemoryEvents.Value)
			{
				_events.RemoveAt(0);
			}
			if (_enableConsoleLogging.Value)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)($"[Fishing] {ev.Timestamp:HH:mm:ss} {ev.EventType} | " + $"Player={ev.PlayerName} | Biome={ev.Biome} | Pos={ev.Position} | " + $"Item={ev.ItemPrefab}/{ev.ItemName} x{ev.ItemAmount} q{ev.ItemQuality} | {ev.Notes}"));
				}
			}
		}

		private void TryRegisterConsoleCommands()
		{
			try
			{
				if (CommandManager.Instance != null)
				{
					CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new FishLogCommand());
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogInfo((object)"[FishingTracker] Comando de consola 'fishlog' registrado (Jötunn).");
					}
				}
				else
				{
					ManualLogSource log2 = Log;
					if (log2 != null)
					{
						log2.LogWarning((object)"[FishingTracker] CommandManager.Instance es null, no se registró comando 'fishlog'.");
					}
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log3 = Log;
				if (log3 != null)
				{
					log3.LogWarning((object)$"[FishingTracker] No se pudo registrar comando 'fishlog': {arg}");
				}
			}
		}

		internal static string GetPlayerBiome(Player player)
		{
			//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)
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(Player), "m_currentBiome");
				if (fieldInfo != null)
				{
					Biome val = (Biome)fieldInfo.GetValue(player);
					return ((object)(Biome)(ref val)).ToString();
				}
			}
			catch
			{
			}
			return "Unknown";
		}
	}
	internal static class FishingTugOfWarMiniGame
	{
		internal class State
		{
			public FishingFloat Float;

			public Player Player;

			public Fish Fish;

			public float FishPos;

			public float DriftTimer;

			public bool Active;

			public bool IsPreview;

			public float Durability;

			public string FishName;

			public int FishLevel;

			public Sprite FishIconSprite;

			public Texture2D FishIconTexture;

			public float TensionRisk;
		}

		internal static State _current;

		private static bool _uiCreated;

		internal const float BlueFrac = 0.5f;

		internal const float OrangeFrac = 0.35f;

		internal const float RedFrac = 0.15f;

		private const float MaxPos = 1.2f;

		private const float BaseDriftSpeed = 0.6f;

		private const float RandomDriftStrength = 0.3f;

		private const float InputPower = 2.8f;

		private const float CaptureProgressPerSecond = 0.045f;

		private const float OrangeRiskPerSecond = 0.6f;

		private const float RedRiskPerSecond = 1.3f;

		private const float RiskDecayPerSecond = 0.2f;

		private static Texture2D _roundTex;

		private static Texture2D _gradientTex;

		public static bool IsActive => _current != null && _current.Active;

		public static void EnsureUI()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!_uiCreated)
			{
				_uiCreated = true;
				GameObject val = new GameObject("FishingTugOfWarUI");
				Object.DontDestroyOnLoad((Object)(object)val);
				val.AddComponent<FishingTugOfWarUI>();
			}
		}

		private static void ExtractFishInfo(Fish fish, out string fishName, out int fishLevel)
		{
			fishName = "Fish";
			fishLevel = 1;
			if ((Object)(object)fish == (Object)null)
			{
				ManualLogSource log = FishingTracker.Log;
				if (log != null)
				{
					log.LogWarning((object)"[TugOfWar] ExtractFishInfo: fish=null");
				}
				return;
			}
			string text = "";
			string text2 = "";
			int num = 1;
			try
			{
				text = fish.GetHoverName();
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = FishingTracker.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)$"[TugOfWar] GetHoverName exception: {arg}");
				}
			}
			try
			{
				if (fish.m_itemDrop?.m_itemData != null)
				{
					ItemData itemData = fish.m_itemDrop.m_itemData;
					num = Mathf.Max(1, itemData.m_quality);
					if (!string.IsNullOrEmpty(itemData.m_shared?.m_name))
					{
						text2 = itemData.m_shared.m_name;
					}
				}
			}
			catch (Exception arg2)
			{
				ManualLogSource log3 = FishingTracker.Log;
				if (log3 != null)
				{
					log3.LogWarning((object)$"[TugOfWar] m_itemDrop read exception: {arg2}");
				}
			}
			fishName = ((!string.IsNullOrEmpty(text2)) ? text2 : ((!string.IsNullOrEmpty(text)) ? text : ((Object)fish).name));
			fishLevel = num;
			ManualLogSource log4 = FishingTracker.Log;
			if (log4 != null)
			{
				log4.LogInfo((object)("[TugOfWar] FishInfo => unityName='" + ((Object)fish).name + "', hover='" + text + "', " + $"sharedName='{text2}', finalName='{fishName}', level={fishLevel}"));
			}
		}

		private static void ExtractFishIcon(Fish fish, out Sprite iconSprite, out Texture2D iconTexture)
		{
			iconSprite = null;
			iconTexture = null;
			try
			{
				Sprite[] array = fish?.m_itemDrop?.m_itemData?.m_shared?.m_icons;
				if (array != null && array.Length != 0 && (Object)(object)array[0] != (Object)null)
				{
					iconSprite = array[0];
					iconTexture = iconSprite.texture;
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log = FishingTracker.Log;
				if (log != null)
				{
					log.LogWarning((object)$"[TugOfWar] ExtractFishIcon exception: {arg}");
				}
			}
		}

		public static bool IsActiveFor(FishingFloat f)
		{
			return IsActive && !_current.IsPreview && (Object)(object)_current.Float == (Object)(object)f;
		}

		public static void Start(FishingFloat floatObj, Player player, Fish fish)
		{
			if (!((Object)(object)floatObj == (Object)null) && !((Object)(object)player == (Object)null) && !((Object)(object)fish == (Object)null) && !((Object)(object)Player.m_localPlayer != (Object)(object)player))
			{
				ExtractFishInfo(fish, out var fishName, out var fishLevel);
				ExtractFishIcon(fish, out var iconSprite, out var iconTexture);
				_current = new State
				{
					Float = floatObj,
					Player = player,
					Fish = fish,
					FishPos = 0f,
					DriftTimer = 0f,
					Active = true,
					IsPreview = false,
					Durability = 1f,
					FishName = fishName,
					FishLevel = fishLevel,
					FishIconSprite = iconSprite,
					FishIconTexture = iconTexture,
					TensionRisk = 0f
				};
				((Character)player).Message((MessageType)2, Localization.instance.Localize("$msg_fishing_hooked"), 0, (Sprite)null);
			}
		}

		public static void StartPreview(Player player)
		{
			if (!((Object)(object)player == (Object)null))
			{
				_current = new State
				{
					Float = null,
					Player = player,
					Fish = null,
					FishPos = 0f,
					DriftTimer = 0f,
					Active = true,
					IsPreview = true,
					Durability = 1f,
					FishName = "Fish",
					FishLevel = 1,
					FishIconSprite = null,
					FishIconTexture = null,
					TensionRisk = 0f
				};
			}
		}

		public static void Cancel(string reason)
		{
			if (_current != null)
			{
				_current.Active = false;
				_current = null;
			}
		}

		internal static void Fail(string reason)
		{
			if (_current == null)
			{
				return;
			}
			if (!_current.IsPreview)
			{
				Player player = _current.Player;
				if (player != null)
				{
					((Character)player).Message((MessageType)2, Localization.instance.Localize("$msg_fishing_lost"), 0, (Sprite)null);
				}
			}
			ManualLogSource log = FishingTracker.Log;
			if (log != null)
			{
				log.LogInfo((object)("[TugOfWar] FAIL (" + reason + ")"));
			}
			_current.Active = false;
			_current = null;
		}

		private static void Success()
		{
			if (_current == null)
			{
				return;
			}
			if (!_current.IsPreview)
			{
				string text = FishingFloat.Catch(_current.Fish, (Character)(object)_current.Player);
				_current.Float.Message(text, true);
				_current.Float.SetCatch((Fish)null);
				_current.Fish.OnHooked((FishingFloat)null);
				ZNetView nview = _current.Float.m_nview;
				if (nview != null)
				{
					nview.Destroy();
				}
				ManualLogSource log = FishingTracker.Log;
				if (log != null)
				{
					log.LogInfo((object)$"[TugOfWar] SUCCESS: player={_current.Player.GetPlayerName()}, fish='{_current.FishName}', level={_current.FishLevel}");
				}
			}
			_current.Active = false;
			_current = null;
		}

		public static void NotifyFloatDestroyed(FishingFloat f)
		{
			if ((Object)(object)_current?.Float == (Object)(object)f)
			{
				Cancel("float destroyed");
			}
		}

		private static float GetFishingSkillLevel(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return 0f;
			}
			try
			{
				Skills skills = ((Character)p).GetSkills();
				if ((Object)(object)skills == (Object)null)
				{
					return 0f;
				}
				return skills.GetSkill((SkillType)104)?.m_level ?? 0f;
			}
			catch (Exception arg)
			{
				ManualLogSource log = FishingTracker.Log;
				if (log != null)
				{
					log.LogWarning((object)$"[TugOfWar] GetFishingSkillLevel exception: {arg}");
				}
				return 0f;
			}
		}

		public static void Update(float dt)
		{
			if (!IsActive)
			{
				return;
			}
			State current = _current;
			Player player = current.Player;
			if ((Object)(object)player == (Object)null || (Object)(object)Player.m_localPlayer != (Object)(object)player)
			{
				Cancel("player mismatch");
				return;
			}
			if (current.IsPreview)
			{
				current.FishPos = Mathf.Sin(Time.time * 1.5f) * 0.8f;
				current.Durability = 1f;
				current.TensionRisk = 0f;
				return;
			}
			float num = Mathf.Clamp01((float)(current.FishLevel - 1) / 4f);
			float fishingSkillLevel = GetFishingSkillLevel(player);
			float num2 = Mathf.Clamp01(fishingSkillLevel / 100f);
			float num3 = 1f + 4f * num;
			float num4 = Mathf.Lerp(1f, 0.8f, num2);
			float num5 = num3 * num4;
			float num6 = 1f - 0.6f * num;
			float num7 = Mathf.Lerp(1f, 1.15f, num2);
			float num8 = num6 * num7;
			float num9 = Mathf.Lerp(1.15f, 0.8f, num2);
			float num10 = Mathf.Lerp(1f, 1.25f, num2);
			current.DriftTimer -= dt;
			float num11 = 0.6f;
			if (current.DriftTimer <= 0f)
			{
				num11 = 0.6f + Random.Range(-0.3f, 0.3f);
				if (num11 < 0.3f)
				{
					num11 = 0.3f;
				}
				current.DriftTimer = Random.Range(0.7f, 1.3f);
			}
			num11 *= num5;
			float num12 = Mathf.Abs(num11);
			float num13 = (Input.GetMouseButton(1) ? (-2.8f) : 0f);
			current.FishPos += (num12 + num13) * dt;
			if (current.FishPos > 1.2f)
			{
				Fail("out of bounds right");
				return;
			}
			if (current.FishPos < -1f)
			{
				current.FishPos = -1f;
			}
			float num14 = Mathf.InverseLerp(-1f, 1f, Mathf.Clamp(current.FishPos, -1f, 1f));
			float num15 = 0.5f;
			float num16 = num15;
			float num17 = num15 + 0.35f;
			float num18 = num17;
			float num19 = 1f;
			bool flag = num14 >= 0f && num14 <= num15;
			bool flag2 = num14 >= num16 && num14 <= num17;
			bool flag3 = num14 >= num18 && num14 <= num19;
			if (flag)
			{
				current.Durability -= 0.045f * num8 * dt;
			}
			current.Durability = Mathf.Clamp01(current.Durability);
			if (current.Durability <= 0f)
			{
				Success();
				return;
			}
			if (flag)
			{
				current.TensionRisk -= 0.2f * num10 * dt;
			}
			else if (flag2)
			{
				current.TensionRisk += 0.6f * num9 * dt;
			}
			else if (flag3)
			{
				current.TensionRisk += 1.3f * num9 * dt;
			}
			current.TensionRisk = Mathf.Clamp01(current.TensionRisk);
			if (current.TensionRisk >= 1f)
			{
				Fail("tension overflow");
			}
		}

		private static void EnsureRoundTexture()
		{
			//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_0028: 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_003e: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_roundTex != (Object)null)
			{
				return;
			}
			_roundTex = new Texture2D(64, 64, (TextureFormat)4, false)
			{
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)1,
				hideFlags = (HideFlags)61
			};
			float num = 31.5f;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(32f, 32f);
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					float num2 = Vector2.Distance(new Vector2((float)j, (float)i), val);
					_roundTex.SetPixel(j, i, (Color)((num2 <= num) ? Color.white : new Color(1f, 1f, 1f, 0f)));
				}
			}
			_roundTex.Apply();
		}

		private static void EnsureGradientTexture()
		{
			//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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: 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_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_gradientTex != (Object)null)
			{
				return;
			}
			_gradientTex = new Texture2D(256, 1, (TextureFormat)4, false)
			{
				wrapMode = (TextureWrapMode)1,
				filterMode = (FilterMode)1,
				hideFlags = (HideFlags)61
			};
			Color val = default(Color);
			((Color)(ref val))..ctor(0.05f, 0.15f, 0.4f, 1f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.2f, 0.8f, 0.95f, 1f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.1f, 0.85f, 0.2f, 1f);
			Color val4 = default(Color);
			((Color)(ref val4))..ctor(0.95f, 0.9f, 0.2f, 1f);
			Color val5 = default(Color);
			((Color)(ref val5))..ctor(0.98f, 0.64f, 0.2f, 1f);
			Color val6 = default(Color);
			((Color)(ref val6))..ctor(0.9f, 0.2f, 0.15f, 1f);
			for (int i = 0; i < 256; i++)
			{
				float num = (float)i / 255f;
				float num2 = 0.5f;
				float num3 = 0.85f;
				Color val7;
				if (num <= num2)
				{
					float num4 = Mathf.InverseLerp(0f, num2, num);
					if (num4 < 0.33f)
					{
						float num5 = Mathf.InverseLerp(0f, 0.33f, num4);
						val7 = Color.Lerp(val, val2, num5);
					}
					else if (num4 < 0.66f)
					{
						float num6 = Mathf.InverseLerp(0.33f, 0.66f, num4);
						val7 = Color.Lerp(val2, val3, num6);
					}
					else
					{
						float num7 = Mathf.InverseLerp(0.66f, 1f, num4);
						val7 = Color.Lerp(val3, val4, num7);
					}
				}
				else if (num <= num3)
				{
					float num8 = Mathf.InverseLerp(num2, num3, num);
					if (num8 < 0.5f)
					{
						float num9 = Mathf.InverseLerp(0f, 0.5f, num8);
						val7 = Color.Lerp(val4, val5, num9);
					}
					else
					{
						float num10 = Mathf.InverseLerp(0.5f, 1f, num8);
						val7 = Color.Lerp(val5, val6, num10);
					}
				}
				else
				{
					float num11 = Mathf.InverseLerp(num3, 1f, num);
					val7 = Color.Lerp(val6, new Color(0.4f, 0f, 0f, 1f), num11 * 0.5f);
				}
				_gradientTex.SetPixel(i, 0, val7);
			}
			_gradientTex.Apply();
		}

		public static void OnGUI()
		{
			//IL_07e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Expected O, but got Unknown
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_051a: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_070b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0716: Unknown result type (might be due to invalid IL or missing references)
			//IL_071a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0791: Unknown result type (might be due to invalid IL or missing references)
			//IL_0796: Unknown result type (might be due to invalid IL or missing references)
			//IL_079e: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b1: Expected O, but got Unknown
			//IL_07d2: Unknown result type (might be due to invalid IL or missing references)
			if (!IsActive || (Object)(object)Player.m_localPlayer == (Object)null)
			{
				return;
			}
			EnsureRoundTexture();
			EnsureGradientTexture();
			Texture2D whiteTexture = Texture2D.whiteTexture;
			Color color = GUI.color;
			float num = 720f;
			float num2 = 32f;
			float num3 = ((float)Screen.width - num) / 2f;
			float num4 = (float)Screen.height - 190f;
			State current = _current;
			GUI.color = new Color(0f, 0f, 0f, 0.45f);
			GUI.DrawTexture(new Rect(num3 - 10f, num4 - 10f, num + 20f, num2 + 60f), (Texture)(object)whiteTexture);
			GUI.color = new Color(0.15f, 0.1f, 0.06f, 0.98f);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(num3, num4, num, num2);
			GUI.DrawTexture(val, (Texture)(object)whiteTexture);
			float num5 = 6f;
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(((Rect)(ref val)).x + num5, ((Rect)(ref val)).y + num5, ((Rect)(ref val)).width - num5 * 2f, ((Rect)(ref val)).height - num5 * 2f);
			GUI.color = new Color(0.04f, 0.04f, 0.05f, 0.95f);
			GUI.DrawTexture(val2, (Texture)(object)_roundTex);
			Rect val3 = default(Rect);
			((Rect)(ref val3))..ctor(((Rect)(ref val2)).x + 4f, ((Rect)(ref val2)).y + 3f, ((Rect)(ref val2)).width - 8f, ((Rect)(ref val2)).height - 6f);
			GUI.color = Color.white;
			GUI.DrawTexture(val3, (Texture)(object)_gradientTex);
			float num6 = Mathf.InverseLerp(-1f, 1f, Mathf.Clamp(current.FishPos, -1f, 1f));
			float num7 = Mathf.Lerp(((Rect)(ref val3)).x + 10f, ((Rect)(ref val3)).xMax - 10f, num6);
			float num8 = FishingTracker.FishIconSizeConfig?.Value ?? 72f;
			if ((Object)(object)current.FishIconTexture != (Object)null && (Object)(object)current.FishIconSprite != (Object)null)
			{
				Sprite fishIconSprite = current.FishIconSprite;
				float num9 = num8;
				Rect rect = fishIconSprite.rect;
				float width = ((Rect)(ref rect)).width;
				rect = fishIconSprite.rect;
				float num10 = width / Mathf.Max(1f, ((Rect)(ref rect)).height);
				float num11 = num9 * num10;
				float num12 = ((Rect)(ref val3)).y - num9 * 0.7f;
				Rect val4 = default(Rect);
				((Rect)(ref val4))..ctor(num7 - num11 / 2f, num12, num11, num9);
				Rect textureRect = fishIconSprite.textureRect;
				Rect val5 = default(Rect);
				((Rect)(ref val5))..ctor(((Rect)(ref textureRect)).x / (float)((Texture)fishIconSprite.texture).width, ((Rect)(ref textureRect)).y / (float)((Texture)fishIconSprite.texture).height, ((Rect)(ref textureRect)).width / (float)((Texture)fishIconSprite.texture).width, ((Rect)(ref textureRect)).height / (float)((Texture)fishIconSprite.texture).height);
				GUI.color = Color.white;
				GUI.DrawTextureWithTexCoords(val4, (Texture)(object)fishIconSprite.texture, val5);
			}
			else
			{
				GUI.color = new Color(1f, 0.9f, 0.2f, 1f);
				GUI.DrawTexture(new Rect(num7 - 10f, ((Rect)(ref val3)).y - 5f, 20f, 15f), (Texture)(object)whiteTexture);
			}
			float num13 = 12f;
			float num14 = ((Rect)(ref val)).yMax + 12f;
			float num15 = num * 0.25f;
			float num16 = num * 0.35f;
			float num17 = num15 + 8f + num16;
			float num18 = num3 + (num - num17) / 2f;
			string arg = Localization.instance.Localize(current.FishName ?? "Fish");
			string text = $"<color=#BFFF00>{arg}</color> <b><color=#FFFFFF>Lv{current.FishLevel}</color></b>";
			GUIStyle val6 = new GUIStyle(GUI.skin.label)
			{
				alignment = (TextAnchor)5,
				fontSize = 14,
				richText = true
			};
			Rect val7 = default(Rect);
			((Rect)(ref val7))..ctor(num18, num14 - 2f, num15, num13 + 4f);
			GUI.Label(val7, text, val6);
			float num19 = num18 + num15 + 8f;
			Rect val8 = default(Rect);
			((Rect)(ref val8))..ctor(num19 - 4f, num14 - 4f, num16 + 8f, num13 + 8f);
			GUI.color = new Color(0f, 0f, 0f, 0.55f);
			GUI.DrawTexture(val8, (Texture)(object)whiteTexture);
			Rect val9 = default(Rect);
			((Rect)(ref val9))..ctor(num19, num14, num16, num13);
			GUI.color = new Color(0.06f, 0.06f, 0.07f, 0.96f);
			GUI.DrawTexture(val9, (Texture)(object)whiteTexture);
			Rect val10 = default(Rect);
			((Rect)(ref val10))..ctor(num19 - 1f, num14 - 1f, num16 + 2f, num13 + 2f);
			GUI.color = new Color(0.27f, 0.27f, 0.29f, 0.95f);
			GUI.DrawTexture(val10, (Texture)(object)whiteTexture);
			float num20 = num16 * Mathf.Clamp01(current.Durability);
			Rect val11 = default(Rect);
			((Rect)(ref val11))..ctor(num19, num14, num20, num13);
			float num21 = Mathf.Clamp01(current.TensionRisk);
			Color color2 = default(Color);
			if (num21 < 0.25f)
			{
				((Color)(ref color2))..ctor(0.2f, 0.88f, 0.3f, 1f);
			}
			else if (num21 < 0.5f)
			{
				((Color)(ref color2))..ctor(0.95f, 0.9f, 0.2f, 1f);
			}
			else if (num21 < 0.75f)
			{
				((Color)(ref color2))..ctor(0.98f, 0.64f, 0.2f, 1f);
			}
			else
			{
				((Color)(ref color2))..ctor(0.9f, 0.2f, 0.15f, 1f);
			}
			GUI.color = color2;
			GUI.DrawTexture(val11, (Texture)(object)whiteTexture);
			try
			{
				Player player = current.Player;
				ItemData val12 = ((player != null) ? ((Humanoid)player).GetRightItem() : null);
				Sprite val13 = null;
				Texture2D val14 = null;
				Sprite[] array = val12?.m_shared?.m_icons;
				if (array != null && array.Length != 0 && (Object)(object)array[0] != (Object)null)
				{
					val13 = array[0];
					val14 = val13.texture;
				}
				float num22 = num4 - 10f + num2 + 60f;
				float num23 = 56f;
				float num24 = num3 + 10f;
				float num25 = num22 - num23;
				if ((Object)(object)val14 != (Object)null && (Object)(object)val13 != (Object)null)
				{
					Rect textureRect2 = val13.textureRect;
					Rect val15 = default(Rect);
					((Rect)(ref val15))..ctor(((Rect)(ref textureRect2)).x / (float)((Texture)val14).width, ((Rect)(ref textureRect2)).y / (float)((Texture)val14).height, ((Rect)(ref textureRect2)).width / (float)((Texture)val14).width, ((Rect)(ref textureRect2)).height / (float)((Texture)val14).height);
					Rect val16 = default(Rect);
					((Rect)(ref val16))..ctor(num24, num25, num23, num23);
					GUI.color = Color.white;
					GUI.DrawTextureWithTexCoords(val16, (Texture)(object)val14, val15);
				}
				Skills skills = ((Character)current.Player).GetSkills();
				float valueOrDefault = ((skills == null) ? null : skills.GetSkill((SkillType)104)?.m_level).GetValueOrDefault();
				int num26 = Mathf.RoundToInt(valueOrDefault);
				string text2 = $"<b><color=#FFFFFF>Lv{num26}</color></b>";
				GUIStyle val17 = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)3,
					fontSize = 14,
					richText = true
				};
				Rect val18 = default(Rect);
				((Rect)(ref val18))..ctor(num24 + num23 + 6f, num25 + 6f, 80f, num23);
				GUI.Label(val18, text2, val17);
			}
			catch
			{
			}
			GUI.color = color;
		}
	}
	public class FishingTugOfWarUI : MonoBehaviour
	{
		private void Update()
		{
			FishingTugOfWarMiniGame.Update(Time.deltaTime);
		}

		private void OnGUI()
		{
			FishingTugOfWarMiniGame.OnGUI();
		}
	}
	[HarmonyPatch(typeof(Humanoid), "Pickup")]
	public static class Humanoid_Pickup_Patch
	{
		private static void Postfix(Humanoid __instance, GameObject go, bool autoequip, bool autoPickupDelay, bool __result)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			if (!__result || (Object)(object)FishingTracker.Instance == (Object)null || (Object)(object)go == (Object)null)
			{
				return;
			}
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if (val != null)
			{
				ItemDrop component = go.GetComponent<ItemDrop>();
				if (!((Object)(object)component == (Object)null) && IsFishItem(component))
				{
					ItemData itemData = component.m_itemData;
					Vector3 position = ((Component)val).transform.position;
					int itemAmount = itemData?.m_stack ?? 1;
					FishingTracker.FishingEvent ev = new FishingTracker.FishingEvent
					{
						Timestamp = DateTime.Now,
						EventType = "Catch",
						PlayerName = val.GetPlayerName(),
						Biome = FishingTracker.GetPlayerBiome(val),
						Position = position,
						ItemPrefab = ((Object)go).name,
						ItemName = (itemData?.m_shared?.m_name ?? ""),
						ItemQuality = (itemData?.m_quality ?? 0),
						ItemAmount = itemAmount,
						Notes = $"from Humanoid.Pickup (autoequip={autoequip}, autoPickupDelay={autoPickupDelay})"
					};
					FishingTracker.Instance.RegisterEvent(ev);
				}
			}
		}

		private static bool IsFishItem(ItemDrop item)
		{
			try
			{
				string text = ((Object)item).name.ToLowerInvariant();
				if (text.Contains("fish"))
				{
					return true;
				}
				SharedData val = item.m_itemData?.m_shared;
				if (!string.IsNullOrEmpty(val?.m_name) && val.m_name.ToLowerInvariant().Contains("fish"))
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}
	}
}
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;
		}
	}
}
internal static class AnimationSpeedManager
{
	public delegate double Handler(Character character, double speed);

	private static readonly Harmony harmony = new Harmony("AnimationSpeedManager");

	private static bool hasMarkerPatch = false;

	private static readonly MethodInfo method = AccessTools.DeclaredMethod(typeof(CharacterAnimEvent), "CustomFixedUpdate", (Type[])null, (Type[])null);

	private static int index = 0;

	private static bool changed = false;

	private static Handler[][] handlers = Array.Empty<Handler[]>();

	private static readonly Dictionary<int, List<Handler>> handlersPriorities = new Dictionary<int, List<Handler>>();

	[PublicAPI]
	public static void Add(Handler handler, int priority = 400)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Expected O, but got Unknown
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Expected O, but got Unknown
		if (!hasMarkerPatch)
		{
			harmony.Patch((MethodBase)method, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(AnimationSpeedManager), "markerPatch", (Type[])null, (Type[])null)), (HarmonyMethod)null);
			hasMarkerPatch = true;
		}
		if (!handlersPriorities.TryGetValue(priority, out List<Handler> value))
		{
			handlersPriorities.Add(priority, value = new List<Handler>());
			harmony.Patch((MethodBase)method, (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(AnimationSpeedManager), "wrapper", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		value.Add(handler);
		handlers = (from kv in handlersPriorities
			orderby kv.Key
			select kv.Value.ToArray()).ToArray();
	}

	private static void wrapper(Character ___m_character, Animator ___m_animator)
	{
		Character ___m_character2 = ___m_character;
		double num = (double)___m_animator.speed * 10000000.0 % 100.0;
		if ((!(num > 10.0) || !(num < 30.0)) && !(___m_animator.speed <= 0.001f))
		{
			double num2 = ___m_animator.speed;
			double num3 = handlers[index++].Aggregate(num2, (double current, Handler handler) => handler(___m_character2, current));
			if (num3 != num2)
			{
				___m_animator.speed = (float)(num3 - num3 % 1E-05);
				changed = true;
			}
		}
	}

	private static void markerPatch(Animator ___m_animator)
	{
		if (changed)
		{
			double num = (double)___m_animator.speed * 10000000.0 % 100.0;
			if ((num < 10.0 || num > 30.0) ? true : false)
			{
				___m_animator.speed += 1.9E-06f;
			}
			changed = false;
		}
		index = 0;
	}
}