using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using RunesOfRefinement.Config;
using RunesOfRefinement.GUI;
using RunesOfRefinement.Items;
using RunesOfRefinement.Patches;
using RunesOfRefinement.Systems;
using UnityEngine;
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("RunesOfRefinement")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("PickTeam")]
[assembly: AssemblyProduct("RunesOfRefinement")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("3f480584-8125-43c3-acb4-3621017202b6")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = "")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RunesOfRefinement
{
	[BepInPlugin("com.pickteam.RunesOfRefinement", "RunesOfRefinement", "0.5.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	internal class RunesOfRefinement : BaseUnityPlugin
	{
		public const string ModGUID = "com.pickteam.RunesOfRefinement";

		public const string ModName = "RunesOfRefinement";

		public const string ModVersion = "0.5.0";

		private Harmony harmony;

		private CustomLocalization localization;

		private FileSystemWatcher _configWatcher;

		private void Awake()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			ModConfig.Init(((BaseUnityPlugin)this).Config);
			harmony = new Harmony("com.pickteam.RunesOfRefinement");
			harmony.CreateClassProcessor(typeof(BiomeDropPatch)).Patch();
			TooltipPatch.Register(harmony);
			StatPatches.Register(harmony);
			OutOfCombatStaminaPatch.Register(harmony);
			CursorApply.Register(harmony);
			localization = LocalizationManager.Instance.GetLocalization();
			LocalizationManager.Instance.AddLocalization(localization);
			LocaleLoader.LoadAll(localization);
			PrefabManager.OnVanillaPrefabsAvailable += AddContent;
			SynchronizationManager.OnConfigurationSynchronized += OnConfigSync;
			SynchronizationManager.OnAdminStatusChanged += OnAdminStatusChanged;
			SetupConfigWatcher();
			Logger.LogInfo((object)"RunesOfRefinement v0.5.0 loaded");
		}

		private void Update()
		{
			CursorApply.UpdateCursorPosition();
		}

		private void AddContent()
		{
			Spheres.Create();
			Omens.Create();
			PrefabManager.OnVanillaPrefabsAvailable -= AddContent;
		}

		private void OnDestroy()
		{
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
			SynchronizationManager.OnConfigurationSynchronized -= OnConfigSync;
			SynchronizationManager.OnAdminStatusChanged -= OnAdminStatusChanged;
			_configWatcher?.Dispose();
		}

		private void OnConfigSync(object sender, ConfigurationSynchronizationEventArgs e)
		{
			Logger.LogInfo((object)("RunesOfRefinement: configuration " + (e.InitialSynchronization ? "initially synced" : "re-synced") + " from server"));
		}

		private void OnAdminStatusChanged()
		{
			Logger.LogInfo((object)string.Format("{0}: admin status = {1}", "RunesOfRefinement", SynchronizationManager.Instance.PlayerIsAdmin));
		}

		private void SetupConfigWatcher()
		{
			string configFilePath = ((BaseUnityPlugin)this).Config.ConfigFilePath;
			string directoryName = Path.GetDirectoryName(configFilePath);
			string fileName = Path.GetFileName(configFilePath);
			_configWatcher = new FileSystemWatcher(directoryName, fileName)
			{
				NotifyFilter = (NotifyFilters.Size | NotifyFilters.LastWrite),
				EnableRaisingEvents = true
			};
			_configWatcher.Changed += delegate
			{
				((BaseUnityPlugin)this).Config.Reload();
				Logger.LogInfo((object)"RunesOfRefinement: config file changed — reloaded");
			};
		}
	}
}
namespace RunesOfRefinement.Config
{
	public static class ModConfig
	{
		public static ConfigEntry<float> DropRateMultiplier;

		public static ConfigEntry<float> OmenDropRateMultiplier;

		public static ConfigEntry<bool> EnableMythicProperties;

		public static ConfigEntry<float> AffixValueMultiplier;

		public static ConfigEntry<bool> EnableOutOfCombatStamina;

		public static ConfigEntry<bool> EnableTooltipColors;

		public static ConfigEntry<bool> EnableReforgeEffects;

		public static void Init(ConfigFile config)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			config.SaveOnConfigSet = true;
			DropRateMultiplier = config.Bind<float>("DropRates", "SphereDropMultiplier", 1f, new ConfigDescription("Multiplier for all sphere/rune drop rates (1.0 = default, 2.0 = double).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} }));
			OmenDropRateMultiplier = config.Bind<float>("DropRates", "OmenDropMultiplier", 1f, new ConfigDescription("Multiplier for all omen drop rates.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} }));
			EnableMythicProperties = config.Bind<bool>("Features", "EnableMythicProperties", true, new ConfigDescription("Enable or disable mythic (legendary) active properties.", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} }));
			AffixValueMultiplier = config.Bind<float>("Balance", "AffixValueMultiplier", 1f, new ConfigDescription("Multiplier for rolled affix values (1.0 = default, 0.5 = half power).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 5f), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} }));
			EnableOutOfCombatStamina = config.Bind<bool>("Gameplay", "EnableOutOfCombatStamina", true, new ConfigDescription("When enabled, stamina is not consumed while out of combat (not sensed or targeted).", (AcceptableValueBase)null, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} }));
			EnableTooltipColors = config.Bind<bool>("Visual", "EnableTooltipColors", true, "Enable colored text in item tooltips for rune modifiers.");
			EnableReforgeEffects = config.Bind<bool>("Visual", "EnableReforgeEffects", true, "Enable visual/sound effects when reforging at the Enchantment Altar.");
		}
	}
}
namespace RunesOfRefinement.GUI
{
	internal static class CursorApply
	{
		[HarmonyPatch(typeof(InventoryGui), "SetupDragItem")]
		private static class LeftClickPatch
		{
			[HarmonyPostfix]
			private static void Postfix(InventoryGui __instance)
			{
				if (IsHolding && !((Object)(object)__instance.m_dragGo == (Object)null) && __instance.m_dragItem != null)
				{
					ItemData dragItem = __instance.m_dragItem;
					GameObject dropPrefab = dragItem.m_dropPrefab;
					string prefabName = ((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? "";
					if (EssenceLogic.IsOmen(prefabName))
					{
						_heldOmen = dragItem;
						__instance.SetupDragItem((ItemData)null, (Inventory)null, 1);
						UpdateCursorVisual();
					}
				}
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "OnRightClick")]
		private static class RightClickPatch
		{
			[HarmonyPrefix]
			private static bool Prefix(InventoryGrid __instance, UIInputHandler element)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				GameObject gameObject = ((Component)element).gameObject;
				Vector2i buttonPos = __instance.GetButtonPos(gameObject);
				ItemData itemAt = __instance.m_inventory.GetItemAt(buttonPos.x, buttonPos.y);
				if (!IsHolding)
				{
					if (itemAt == null)
					{
						return true;
					}
					GameObject dropPrefab = itemAt.m_dropPrefab;
					string prefabName = ((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? "";
					if (EssenceLogic.IsSphere(prefabName))
					{
						Hold(itemAt);
						return false;
					}
					return true;
				}
				if (itemAt == null)
				{
					Cancel();
					return false;
				}
				GameObject dropPrefab2 = itemAt.m_dropPrefab;
				string prefabName2 = ((dropPrefab2 != null) ? ((Object)dropPrefab2).name : null) ?? "";
				if (EssenceLogic.IsSphere(prefabName2))
				{
					Hold(itemAt);
					return false;
				}
				if (EssenceLogic.IsOmen(prefabName2))
				{
					_heldOmen = itemAt;
					InventoryGui instance = InventoryGui.instance;
					if (instance != null)
					{
						instance.SetupDragItem((ItemData)null, (Inventory)null, 1);
					}
					UpdateCursorVisual();
					return false;
				}
				TryApply(itemAt, __instance.m_inventory);
				return false;
			}
		}

		[HarmonyPatch(typeof(InventoryGrid), "UpdateGui")]
		private static class GridHighlightPatch
		{
			[HarmonyPostfix]
			private static void Postfix(InventoryGrid __instance)
			{
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				if (!IsHolding)
				{
					return;
				}
				ItemData heldSphere = _heldSphere;
				object obj;
				if (heldSphere == null)
				{
					obj = null;
				}
				else
				{
					GameObject dropPrefab = heldSphere.m_dropPrefab;
					obj = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
				}
				if (obj == null)
				{
					obj = "";
				}
				string spherePrefab = (string)obj;
				int width = __instance.m_inventory.m_width;
				foreach (ItemData allItem in __instance.m_inventory.GetAllItems())
				{
					if (!EssenceLogic.IsEquipment(allItem))
					{
						continue;
					}
					int num = allItem.m_gridPos.y * width + allItem.m_gridPos.x;
					if (num < 0 || num >= __instance.m_elements.Count)
					{
						continue;
					}
					Element val = __instance.m_elements[num];
					Transform val2 = val.m_go.transform.Find("selected");
					if (!((Object)(object)val2 == (Object)null))
					{
						Image component = ((Component)val2).GetComponent<Image>();
						if (!((Object)(object)component == (Object)null))
						{
							bool flag = EssenceLogic.CanApply(allItem, spherePrefab);
							((Component)val2).gameObject.SetActive(true);
							((Graphic)component).color = (flag ? HighlightValid : HighlightInvalid);
						}
					}
				}
			}
		}

		private static ItemData _heldSphere;

		private static ItemData _heldOmen;

		private static GameObject _cursorGo;

		private static Image _cursorIcon;

		private static Image _cursorOmenIcon;

		private static readonly Color HighlightValid = new Color(0.2f, 1f, 0.2f, 0.35f);

		private static readonly Color HighlightInvalid = new Color(1f, 0.2f, 0.2f, 0.25f);

		private static readonly Color CursorBg = new Color(0.1f, 0.05f, 0.02f, 0.92f);

		public static bool IsHolding => _heldSphere != null;

		public static void Hold(ItemData sphere, ItemData omen = null)
		{
			_heldSphere = sphere;
			_heldOmen = omen;
			if ((Object)(object)InventoryGui.instance != (Object)null)
			{
				InventoryGui.instance.SetupDragItem((ItemData)null, (Inventory)null, 1);
			}
			EnsureCursor();
			UpdateCursorVisual();
			GameObject dropPrefab = sphere.m_dropPrefab;
			string obj = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
			object obj2;
			if (omen == null)
			{
				obj2 = "";
			}
			else
			{
				GameObject dropPrefab2 = omen.m_dropPrefab;
				obj2 = " + " + ((dropPrefab2 != null) ? ((Object)dropPrefab2).name : null);
			}
			Logger.LogInfo((object)("[RoR] Cursor-hold: " + obj + (string?)obj2));
		}

		public static void Cancel()
		{
			_heldSphere = null;
			_heldOmen = null;
			if ((Object)(object)_cursorGo != (Object)null)
			{
				_cursorGo.SetActive(false);
			}
		}

		public static void TryApply(ItemData target, Inventory targetInventory)
		{
			if (_heldSphere == null || target == null)
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			if (!inventory.ContainsItem(_heldSphere))
			{
				ShowMessage("$ror_msg_missing_items");
				Cancel();
				return;
			}
			if (!EssenceLogic.IsEquipment(target))
			{
				ShowMessage("$ror_msg_not_equipment");
				return;
			}
			GameObject dropPrefab = _heldSphere.m_dropPrefab;
			string spherePrefab = ((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? "";
			ItemData heldOmen = _heldOmen;
			object obj;
			if (heldOmen == null)
			{
				obj = null;
			}
			else
			{
				GameObject dropPrefab2 = heldOmen.m_dropPrefab;
				obj = ((dropPrefab2 != null) ? ((Object)dropPrefab2).name : null);
			}
			if (obj == null)
			{
				obj = "";
			}
			string omenPrefab = (string)obj;
			EssenceLogic.ApplyResult applyResult = EssenceLogic.Apply(target, _heldSphere, _heldOmen);
			if (applyResult.Success)
			{
				inventory.RemoveOneItem(_heldSphere);
				if (_heldOmen != null)
				{
					inventory.RemoveOneItem(_heldOmen);
				}
				PlayEffect(localPlayer);
				RuneEffectManager.Invalidate();
				ItemData val = ((IEnumerable<ItemData>)inventory.GetAllItems()).FirstOrDefault((Func<ItemData, bool>)delegate(ItemData i)
				{
					GameObject dropPrefab4 = i.m_dropPrefab;
					return (((dropPrefab4 != null) ? ((Object)dropPrefab4).name : null) ?? "") == spherePrefab;
				});
				ItemData heldOmen2 = null;
				if (omenPrefab != "")
				{
					heldOmen2 = ((IEnumerable<ItemData>)inventory.GetAllItems()).FirstOrDefault((Func<ItemData, bool>)delegate(ItemData i)
					{
						GameObject dropPrefab3 = i.m_dropPrefab;
						return (((dropPrefab3 != null) ? ((Object)dropPrefab3).name : null) ?? "") == omenPrefab;
					});
				}
				if (val != null)
				{
					_heldSphere = val;
					_heldOmen = heldOmen2;
					UpdateCursorVisual();
				}
				else
				{
					Cancel();
				}
			}
			ShowMessage(applyResult.MessageKey);
		}

		public static void UpdateCursorPosition()
		{
			//IL_0052: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHolding)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				Cancel();
				return;
			}
			if ((Object)(object)_cursorGo != (Object)null && _cursorGo.activeSelf)
			{
				_cursorGo.transform.position = Input.mousePosition + new Vector3(32f, -32f, 0f);
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || !((Humanoid)localPlayer).GetInventory().ContainsItem(_heldSphere))
			{
				Cancel();
			}
		}

		private static void EnsureCursor()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00dc: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Expected O, but got Unknown
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_cursorGo != (Object)null)
			{
				_cursorGo.SetActive(true);
				return;
			}
			InventoryGui instance = InventoryGui.instance;
			Transform val = ((instance != null) ? ((Component)instance).transform.root : null);
			if (!((Object)(object)val == (Object)null))
			{
				_cursorGo = new GameObject("RoR_CursorApply");
				_cursorGo.transform.SetParent(val, false);
				RectTransform val2 = _cursorGo.AddComponent<RectTransform>();
				val2.sizeDelta = new Vector2(52f, 52f);
				Image val3 = _cursorGo.AddComponent<Image>();
				((Graphic)val3).color = CursorBg;
				GameObject val4 = new GameObject("Icon");
				val4.transform.SetParent(_cursorGo.transform, false);
				RectTransform val5 = val4.AddComponent<RectTransform>();
				val5.anchorMin = new Vector2(0f, 0f);
				val5.anchorMax = new Vector2(1f, 1f);
				val5.offsetMin = new Vector2(4f, 4f);
				val5.offsetMax = new Vector2(-4f, -4f);
				_cursorIcon = val4.AddComponent<Image>();
				_cursorIcon.preserveAspect = true;
				GameObject val6 = new GameObject("OmenIcon");
				val6.transform.SetParent(_cursorGo.transform, false);
				RectTransform val7 = val6.AddComponent<RectTransform>();
				val7.anchorMin = new Vector2(1f, 0f);
				val7.anchorMax = new Vector2(1f, 0f);
				val7.pivot = new Vector2(1f, 0f);
				val7.sizeDelta = new Vector2(22f, 22f);
				val7.anchoredPosition = new Vector2(2f, -2f);
				_cursorOmenIcon = val6.AddComponent<Image>();
				_cursorOmenIcon.preserveAspect = true;
				val6.SetActive(false);
				Canvas val8 = _cursorGo.AddComponent<Canvas>();
				val8.overrideSorting = true;
				val8.sortingOrder = 9999;
				_cursorGo.AddComponent<GraphicRaycaster>();
				_cursorGo.SetActive(true);
			}
		}

		private static void UpdateCursorVisual()
		{
			if (!((Object)(object)_cursorGo == (Object)null) && _heldSphere != null)
			{
				_cursorIcon.sprite = _heldSphere.GetIcon();
				((Behaviour)_cursorIcon).enabled = (Object)(object)_cursorIcon.sprite != (Object)null;
				if (_heldOmen != null)
				{
					_cursorOmenIcon.sprite = _heldOmen.GetIcon();
					((Behaviour)_cursorOmenIcon).enabled = (Object)(object)_cursorOmenIcon.sprite != (Object)null;
					((Component)_cursorOmenIcon).gameObject.SetActive(true);
				}
				else
				{
					((Component)_cursorOmenIcon).gameObject.SetActive(false);
				}
			}
		}

		private static void ShowMessage(string key)
		{
			string text = Localization.instance.Localize(key);
			MessageHud instance = MessageHud.instance;
			if (instance != null)
			{
				instance.ShowMessage((MessageType)2, text, 0, (Sprite)null, false);
			}
		}

		private static void PlayEffect(Player player)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.EnableReforgeEffects.Value)
			{
				Vector3 position = ((Component)player).transform.position;
				ZNetScene instance = ZNetScene.instance;
				GameObject val = ((instance != null) ? instance.GetPrefab("sfx_build_hammer_metal") : null);
				if ((Object)(object)val != (Object)null)
				{
					Object.Instantiate<GameObject>(val, position, Quaternion.identity);
				}
				ZNetScene instance2 = ZNetScene.instance;
				GameObject val2 = ((instance2 != null) ? instance2.GetPrefab("vfx_FireAddFuel") : null);
				if ((Object)(object)val2 != (Object)null)
				{
					Object.Instantiate<GameObject>(val2, position, Quaternion.identity);
				}
			}
		}

		public static void Register(Harmony harmony)
		{
			harmony.CreateClassProcessor(typeof(LeftClickPatch)).Patch();
			harmony.CreateClassProcessor(typeof(RightClickPatch)).Patch();
			harmony.CreateClassProcessor(typeof(GridHighlightPatch)).Patch();
		}
	}
}
namespace RunesOfRefinement.Patches
{
	[HarmonyPatch(typeof(CharacterDrop), "Start")]
	internal static class BiomeDropPatch
	{
		private struct DropEntry
		{
			public string Prefab;

			public float Chance;
		}

		private static readonly Dictionary<Biome, List<DropEntry>> BiomeDrops = new Dictionary<Biome, List<DropEntry>>
		{
			[(Biome)1] = new List<DropEntry>
			{
				new DropEntry
				{
					Prefab = "RoR_OrbOfTransmutation",
					Chance = 0.025f
				},
				new DropEntry
				{
					Prefab = "RoR_OrbOfAugmentation",
					Chance = 0.015f
				}
			},
			[(Biome)8] = new List<DropEntry>
			{
				new DropEntry
				{
					Prefab = "RoR_OrbOfTransmutation",
					Chance = 0.015f
				},
				new DropEntry
				{
					Prefab = "RoR_OrbOfAugmentation",
					Chance = 0.015f
				},
				new DropEntry
				{
					Prefab = "RoR_RegalOrb",
					Chance = 0.008f
				}
			},
			[(Biome)2] = new List<DropEntry>
			{
				new DropEntry
				{
					Prefab = "RoR_OrbOfAugmentation",
					Chance = 0.01f
				},
				new DropEntry
				{
					Prefab = "RoR_RegalOrb",
					Chance = 0.012f
				},
				new DropEntry
				{
					Prefab = "RoR_ExaltedOrb",
					Chance = 0.008f
				},
				new DropEntry
				{
					Prefab = "RoR_ChaosOrb",
					Chance = 0.008f
				},
				new DropEntry
				{
					Prefab = "RoR_VaalOrb",
					Chance = 0.005f
				}
			},
			[(Biome)4] = new List<DropEntry>
			{
				new DropEntry
				{
					Prefab = "RoR_RegalOrb",
					Chance = 0.008f
				},
				new DropEntry
				{
					Prefab = "RoR_ExaltedOrb",
					Chance = 0.01f
				},
				new DropEntry
				{
					Prefab = "RoR_OrbOfAlchemy",
					Chance = 0.006f
				},
				new DropEntry
				{
					Prefab = "RoR_ChaosOrb",
					Chance = 0.008f
				},
				new DropEntry
				{
					Prefab = "RoR_VaalOrb",
					Chance = 0.004f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenOfElements",
					Chance = 0.005f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenOfProtector",
					Chance = 0.005f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenOfOrder",
					Chance = 0.005f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenSinistral",
					Chance = 0.003f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenDextral",
					Chance = 0.003f
				}
			},
			[(Biome)16] = new List<DropEntry>
			{
				new DropEntry
				{
					Prefab = "RoR_ExaltedOrb",
					Chance = 0.008f
				},
				new DropEntry
				{
					Prefab = "RoR_OrbOfAlchemy",
					Chance = 0.006f
				},
				new DropEntry
				{
					Prefab = "RoR_ChaosOrb",
					Chance = 0.006f
				},
				new DropEntry
				{
					Prefab = "RoR_OrbOfAnnulment",
					Chance = 0.004f
				},
				new DropEntry
				{
					Prefab = "RoR_VaalOrb",
					Chance = 0.004f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenOfElements",
					Chance = 0.003f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenOfProtector",
					Chance = 0.003f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenOfOrder",
					Chance = 0.003f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenSinistral",
					Chance = 0.002f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenDextral",
					Chance = 0.002f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenWhittling",
					Chance = 0.002f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenAbundance",
					Chance = 0.002f
				}
			},
			[(Biome)512] = new List<DropEntry>
			{
				new DropEntry
				{
					Prefab = "RoR_ExaltedOrb",
					Chance = 0.005f
				},
				new DropEntry
				{
					Prefab = "RoR_ChaosOrb",
					Chance = 0.005f
				},
				new DropEntry
				{
					Prefab = "RoR_OrbOfAnnulment",
					Chance = 0.004f
				},
				new DropEntry
				{
					Prefab = "RoR_DivineOrb",
					Chance = 0.003f
				},
				new DropEntry
				{
					Prefab = "RoR_VaalOrb",
					Chance = 0.005f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenOfElements",
					Chance = 0.003f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenOfProtector",
					Chance = 0.003f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenOfOrder",
					Chance = 0.003f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenSinistral",
					Chance = 0.002f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenDextral",
					Chance = 0.002f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenWhittling",
					Chance = 0.002f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenAbundance",
					Chance = 0.002f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenCorruption",
					Chance = 0.001f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenPerfection",
					Chance = 0.001f
				},
				new DropEntry
				{
					Prefab = "RoR_OmenGreaterAnnul",
					Chance = 0.001f
				}
			}
		};

		private static void Postfix(CharacterDrop __instance)
		{
			//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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			Biome key = Heightmap.FindBiome(((Component)__instance).transform.position);
			if (!BiomeDrops.TryGetValue(key, out var value))
			{
				return;
			}
			foreach (DropEntry item in value)
			{
				GameObject prefab = PrefabManager.Instance.GetPrefab(item.Prefab);
				if (!((Object)(object)prefab == (Object)null))
				{
					__instance.m_drops.Add(new Drop
					{
						m_prefab = prefab,
						m_amountMin = 1,
						m_amountMax = 1,
						m_chance = item.Chance,
						m_onePerPlayer = false,
						m_levelMultiplier = false
					});
				}
			}
		}
	}
	internal static class TooltipPatch
	{
		public static void Register(Harmony harmony)
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(ItemData), "GetTooltip", new Type[5]
			{
				typeof(ItemData),
				typeof(int),
				typeof(bool),
				typeof(float),
				typeof(int)
			}, (Type[])null);
			if (methodInfo == null)
			{
				methodInfo = AccessTools.Method(typeof(ItemData), "GetTooltip", new Type[4]
				{
					typeof(ItemData),
					typeof(int),
					typeof(bool),
					typeof(float)
				}, (Type[])null);
			}
			if (methodInfo == null)
			{
				methodInfo = AccessTools.Method(typeof(ItemData), "GetTooltip", new Type[4]
				{
					typeof(ItemData),
					typeof(int),
					typeof(bool),
					typeof(int)
				}, (Type[])null);
			}
			if (methodInfo != null)
			{
				HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(TooltipPatch), "GetTooltipStaticPostfix", (Type[])null, (Type[])null));
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Logger.LogInfo((object)"TooltipPatch applied (static GetTooltip)");
				return;
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ItemData), "GetTooltip", new Type[1] { typeof(int) }, (Type[])null);
			if (methodInfo2 == null)
			{
				methodInfo2 = AccessTools.Method(typeof(ItemData), "GetTooltip", new Type[3]
				{
					typeof(int),
					typeof(bool),
					typeof(float)
				}, (Type[])null);
			}
			if (methodInfo2 != null)
			{
				HarmonyMethod val2 = new HarmonyMethod(AccessTools.Method(typeof(TooltipPatch), "GetTooltipInstancePostfix", (Type[])null, (Type[])null));
				harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Logger.LogInfo((object)"TooltipPatch applied (instance GetTooltip)");
			}
			else
			{
				Logger.LogWarning((object)"TooltipPatch: Could not find GetTooltip method to patch");
			}
		}

		private static void GetTooltipStaticPostfix(ItemData __0, ref string __result)
		{
			AppendModifiers(__0, ref __result);
		}

		private static void GetTooltipInstancePostfix(ItemData __instance, ref string __result)
		{
			AppendModifiers(__instance, ref __result);
		}

		private static void AppendModifiers(ItemData item, ref string tooltip)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			if (item == null || !ModifierData.HasAnyModifiers(item) || !ModConfig.EnableTooltipColors.Value)
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine();
			stringBuilder.AppendLine();
			ItemRarity rarity = ModifierData.GetRarity(item);
			string text = ColorUtility.ToHtmlStringRGB(RarityHelper.GetColor(rarity));
			string text2 = rarity switch
			{
				ItemRarity.Magic => Localization.instance.Localize("$ror_rarity_magic"), 
				ItemRarity.Rare => Localization.instance.Localize("$ror_rarity_rare"), 
				_ => Localization.instance.Localize("$ror_rarity_normal"), 
			};
			string text3 = (ModifierData.IsCorrupted(item) ? (" <color=#" + ColorUtility.ToHtmlStringRGB(RarityHelper.CorruptedColor) + ">(" + Localization.instance.Localize("$ror_corrupted") + ")</color>") : "");
			int itemTier = EssenceLogic.GetItemTier(item);
			string text4 = Localization.instance.Localize($"$ror_tier_{itemTier}");
			string text5 = " <color=#AAAAAA>[" + text4 + "]</color>";
			stringBuilder.AppendLine("<color=#" + text + ">" + text2 + text3 + text5 + ":</color>");
			List<RolledAffix> affixes = ModifierData.GetAffixes(item);
			affixes.Sort(delegate(RolledAffix a, RolledAffix b)
			{
				AffixDefinition affixDefinition3 = AffixPool.Get(a.AffixId);
				AffixDefinition affixDefinition4 = AffixPool.Get(b.AffixId);
				int num = ((affixDefinition3 == null || affixDefinition3.Slot != 0) ? 1 : 0);
				int value = ((affixDefinition4 == null || affixDefinition4.Slot != 0) ? 1 : 0);
				return num.CompareTo(value);
			});
			foreach (RolledAffix item2 in affixes)
			{
				AffixDefinition affixDefinition = AffixPool.Get(item2.AffixId);
				if (affixDefinition != null)
				{
					string text6 = Localization.instance.Localize(affixDefinition.NameToken);
					string text7 = string.Format(Localization.instance.Localize(affixDefinition.DescToken), item2.Value);
					string rollQualityColor = AffixPool.GetRollQualityColor(item2);
					stringBuilder.AppendLine("<color=" + rollQualityColor + ">" + text6 + ": " + text7 + "</color>");
				}
			}
			RolledAffix mythicAffix = ModifierData.GetMythicAffix(item);
			if (mythicAffix != null)
			{
				AffixDefinition affixDefinition2 = AffixPool.Get(mythicAffix.AffixId);
				if (affixDefinition2 != null)
				{
					string text8 = Localization.instance.Localize(affixDefinition2.NameToken);
					string text9 = string.Format(Localization.instance.Localize(affixDefinition2.DescToken), mythicAffix.Value);
					stringBuilder.AppendLine("<color=#D966FF>" + text8 + ": " + text9 + "</color>");
				}
			}
			tooltip += stringBuilder.ToString();
		}
	}
	internal static class StatPatches
	{
		[HarmonyPatch(typeof(ItemData), "GetDamage", new Type[]
		{
			typeof(int),
			typeof(float)
		})]
		internal static class WeaponDamagePatch
		{
			private static void Postfix(ItemData __instance, ref DamageTypes __result)
			{
				if (!ModifierData.HasAnyModifiers(__instance))
				{
					return;
				}
				RuneEffectManager.WeaponModifiers weaponModifiers = RuneEffectManager.GetWeaponModifiers(__instance);
				if (weaponModifiers.DamagePercent > 0f)
				{
					float num = 1f + weaponModifiers.DamagePercent / 100f;
					__result.m_blunt *= num;
					__result.m_slash *= num;
					__result.m_pierce *= num;
				}
				__result.m_fire += weaponModifiers.FireDamage;
				__result.m_frost += weaponModifiers.FrostDamage;
				__result.m_lightning += weaponModifiers.LightningDamage;
				__result.m_poison += weaponModifiers.PoisonDamage;
				__result.m_spirit += weaponModifiers.SpiritDamage;
				if (weaponModifiers.ArmorIgnore > 0f)
				{
					__result.m_damage += weaponModifiers.ArmorIgnore;
				}
				if (weaponModifiers.HeimdallDamagePercent > 0f)
				{
					float num2 = 1f + weaponModifiers.HeimdallDamagePercent / 100f;
					__result.m_blunt *= num2;
					__result.m_slash *= num2;
					__result.m_pierce *= num2;
					__result.m_fire *= num2;
					__result.m_frost *= num2;
					__result.m_lightning *= num2;
					__result.m_poison *= num2;
					__result.m_spirit *= num2;
				}
				if (!(__result.m_chop > 0f) && !(__result.m_pickaxe > 0f))
				{
					return;
				}
				RuneEffectManager.ToolModifiers toolModifiers = RuneEffectManager.GetToolModifiers(__instance);
				if (toolModifiers.MiningPercent > 0f && __result.m_pickaxe > 0f)
				{
					__result.m_pickaxe *= 1f + toolModifiers.MiningPercent / 100f;
				}
				if (toolModifiers.ChoppingPercent > 0f && __result.m_chop > 0f)
				{
					__result.m_chop *= 1f + toolModifiers.ChoppingPercent / 100f;
				}
				if (toolModifiers.ToolDamagePercent > 0f)
				{
					if (__result.m_chop > 0f)
					{
						__result.m_chop *= 1f + toolModifiers.ToolDamagePercent / 100f;
					}
					if (__result.m_pickaxe > 0f)
					{
						__result.m_pickaxe *= 1f + toolModifiers.ToolDamagePercent / 100f;
					}
				}
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetArmor", new Type[]
		{
			typeof(int),
			typeof(float)
		})]
		internal static class ArmorBonusPatch
		{
			private static void Postfix(ItemData __instance, ref float __result)
			{
				if (ModifierData.HasAnyModifiers(__instance))
				{
					__result += RuneEffectManager.GetArmorBonus(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Update")]
		internal static class PlayerUpdatePatch
		{
			private static void Postfix(Player __instance)
			{
				if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					RuneEffectManager.Recalculate(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(Player), "AddNoise")]
		internal static class NoiseReductionPatch
		{
			private static void Prefix(ref float range)
			{
				if (RuneEffectManager.NoiseReductionPercent > 0f)
				{
					range *= 1f - RuneEffectManager.NoiseReductionPercent / 100f;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "GetTotalFoodValue")]
		internal static class FoodValueBonusPatch
		{
			private static void Postfix(ref float hp, ref float stamina)
			{
				if (RuneEffectManager.MaxHealthBonus > 0f)
				{
					hp += RuneEffectManager.MaxHealthBonus;
				}
				if (RuneEffectManager.MaxStaminaBonus > 0f)
				{
					stamina += RuneEffectManager.MaxStaminaBonus;
				}
			}
		}

		[HarmonyPatch(typeof(SEMan), "ModifyStaminaRegen")]
		internal static class StaminaRegenPatch
		{
			private static void Postfix(ref float staminaMultiplier)
			{
				if (RuneEffectManager.StaminaRegenPercent > 0f)
				{
					staminaMultiplier += RuneEffectManager.StaminaRegenPercent / 100f;
				}
			}
		}

		[HarmonyPatch(typeof(SEMan), "ModifyHealthRegen")]
		internal static class HealthRegenPatch
		{
			private static void Postfix(ref float regenMultiplier)
			{
				if (RuneEffectManager.HpRegenPercent > 0f)
				{
					regenMultiplier += RuneEffectManager.HpRegenPercent / 100f;
				}
			}
		}

		[HarmonyPatch(typeof(SEMan), "ModifyEitrRegen")]
		internal static class EitrRegenPatch
		{
			private static void Postfix(ref float eitrMultiplier)
			{
				if (RuneEffectManager.EitrRegenPercent > 0f)
				{
					eitrMultiplier += RuneEffectManager.EitrRegenPercent / 100f;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "GetEquipmentMovementModifier")]
		internal static class MoveSpeedPatch
		{
			private static void Postfix(ref float __result)
			{
				if (RuneEffectManager.MoveSpeedPercent > 0f)
				{
					__result += RuneEffectManager.MoveSpeedPercent / 100f;
				}
			}
		}

		[HarmonyPatch(typeof(SEMan), "ModifyMaxCarryWeight")]
		internal static class CarryWeightPatch
		{
			private static void Postfix(ref float limit)
			{
				if (RuneEffectManager.CarryWeightBonus > 0f)
				{
					limit += RuneEffectManager.CarryWeightBonus;
				}
			}
		}

		[HarmonyPatch(typeof(Character), "Stagger")]
		internal static class StaggerResistPatch
		{
			private static bool Prefix(Character __instance)
			{
				if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer)
				{
					return true;
				}
				if (RuneEffectManager.StaggerResistPercent <= 0f)
				{
					return true;
				}
				return Random.Range(0f, 100f) > RuneEffectManager.StaggerResistPercent;
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetMaxDurability", new Type[] { typeof(int) })]
		internal static class DurabilityPatch
		{
			private static void Postfix(ItemData __instance, ref float __result)
			{
				if (!ModifierData.HasAnyModifiers(__instance))
				{
					return;
				}
				foreach (RolledAffix affix in ModifierData.GetAffixes(__instance))
				{
					if (affix.AffixId == "durability")
					{
						__result += affix.Value;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Minimap), "UpdateExplore")]
		internal static class ExplorerPatch
		{
			private static void Prefix(Minimap __instance)
			{
				if (RuneEffectManager.ExplorerPercent > 0f)
				{
					__instance.m_exploreRadius = 100f * (1f + RuneEffectManager.ExplorerPercent / 100f);
				}
			}
		}

		[HarmonyPatch(typeof(Skills), "RaiseSkill")]
		internal static class ValhallaPatch
		{
			private static void Prefix(ref float factor)
			{
				if (RuneEffectManager.MythicValhallaXpPercent > 0f)
				{
					factor *= 1f + RuneEffectManager.MythicValhallaXpPercent / 100f;
				}
			}
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		internal static class CombatPatch
		{
			private static bool _inLightningStrike;

			private static void Postfix(Character __instance, HitData hit)
			{
				if (_inLightningStrike)
				{
					return;
				}
				Character attacker = hit.GetAttacker();
				if ((Object)(object)attacker == (Object)null)
				{
					return;
				}
				Player val = (Player)(object)((attacker is Player) ? attacker : null);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val != (Object)(object)Player.m_localPlayer))
				{
					float totalDamage = hit.GetTotalDamage();
					if (RuneEffectManager.LifestealPercent > 0f && totalDamage > 0f)
					{
						float num = totalDamage * RuneEffectManager.LifestealPercent / 100f;
						((Character)val).Heal(num, true);
					}
					if (RuneEffectManager.StaminaOnKill > 0f && __instance.IsDead())
					{
						((Character)val).AddStamina(RuneEffectManager.StaminaOnKill);
					}
					if (RuneEffectManager.MythicLightningChance > 0f && Random.Range(0f, 100f) < RuneEffectManager.MythicLightningChance)
					{
						TriggerLightningStrike(__instance, val);
					}
				}
			}

			private static void TriggerLightningStrike(Character target, Player attacker)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Expected O, but got Unknown
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				_inLightningStrike = true;
				try
				{
					Vector3 position = ((Component)target).transform.position;
					ZNetScene instance = ZNetScene.instance;
					GameObject val = ((instance != null) ? instance.GetPrefab("fx_eikthyr_forceField") : null);
					if ((Object)(object)val != (Object)null)
					{
						Object.Instantiate<GameObject>(val, position + Vector3.up * 0.5f, Quaternion.identity);
					}
					HitData val2 = new HitData();
					val2.m_damage.m_lightning = 30f;
					val2.m_point = position;
					Vector3 val3 = position - ((Component)attacker).transform.position;
					val2.m_dir = ((Vector3)(ref val3)).normalized;
					val2.SetAttacker((Character)(object)attacker);
					target.Damage(val2);
					target.Stagger(val2.m_dir);
				}
				finally
				{
					_inLightningStrike = false;
				}
			}
		}

		[HarmonyPatch(typeof(Character), "SetHealth")]
		internal static class UndyingPatch
		{
			private static float _lastUndyingProc;

			private static void Prefix(Character __instance, ref float health)
			{
				//IL_009f: 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)
				if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || RuneEffectManager.MythicUndyingPercent <= 0f || health > 0f)
				{
					return;
				}
				float time = Time.time;
				if (!(time - _lastUndyingProc < 60f))
				{
					health = __instance.GetMaxHealth() * RuneEffectManager.MythicUndyingPercent / 100f;
					_lastUndyingProc = time;
					ZNetScene instance = ZNetScene.instance;
					GameObject val = ((instance != null) ? instance.GetPrefab("vfx_Potion_health_medium") : null);
					if ((Object)(object)val != (Object)null)
					{
						Object.Instantiate<GameObject>(val, ((Component)__instance).transform.position, Quaternion.identity);
					}
					Logger.LogInfo((object)"Mythic Undying triggered — survived lethal blow!");
				}
			}
		}

		[HarmonyPatch(typeof(Character), "RPC_Damage")]
		internal static class HitModifierPatch
		{
			private static void Prefix(Character __instance, HitData hit)
			{
				Character attacker = hit.GetAttacker();
				if ((Object)(object)attacker == (Object)null)
				{
					return;
				}
				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 currentWeapon = ((Humanoid)val).GetCurrentWeapon();
				if (currentWeapon != null && ModifierData.HasAnyModifiers(currentWeapon))
				{
					RuneEffectManager.WeaponModifiers weaponModifiers = RuneEffectManager.GetWeaponModifiers(currentWeapon);
					if (weaponModifiers.KnockbackPercent > 0f)
					{
						hit.m_pushForce *= 1f + weaponModifiers.KnockbackPercent / 100f;
					}
					float num = weaponModifiers.BackstabBonusPercent + weaponModifiers.CritStrikePercent;
					if (num > 0f)
					{
						hit.m_backstabBonus += num / 100f;
					}
				}
				if (RuneEffectManager.MythicBerserkerPercent > 0f && ((Character)val).GetHealthPercentage() <= 0.3f)
				{
					float num2 = 1f + RuneEffectManager.MythicBerserkerPercent / 100f;
					hit.m_damage.m_damage *= num2;
					hit.m_damage.m_blunt *= num2;
					hit.m_damage.m_slash *= num2;
					hit.m_damage.m_pierce *= num2;
				}
			}
		}

		[HarmonyPatch(typeof(Character), "Damage")]
		internal static class DamageResistancePatch
		{
			private static void Prefix(Character __instance, HitData hit)
			{
				if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					if (RuneEffectManager.FireResistance > 0f)
					{
						hit.m_damage.m_fire *= 1f - Mathf.Clamp01(RuneEffectManager.FireResistance / 100f);
					}
					if (RuneEffectManager.FrostResistance > 0f)
					{
						hit.m_damage.m_frost *= 1f - Mathf.Clamp01(RuneEffectManager.FrostResistance / 100f);
					}
					if (RuneEffectManager.PoisonResistance > 0f)
					{
						hit.m_damage.m_poison *= 1f - Mathf.Clamp01(RuneEffectManager.PoisonResistance / 100f);
					}
					if (RuneEffectManager.ShieldAegisPercent > 0f)
					{
						float num = 1f - Mathf.Clamp01(RuneEffectManager.ShieldAegisPercent / 100f);
						hit.m_damage.m_damage *= num;
						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;
					}
				}
			}
		}

		[HarmonyPatch(typeof(CharacterAnimEvent), "CustomFixedUpdate")]
		internal static class AttackSpeedPatch
		{
			private static void Postfix(Character ___m_character, Animator ___m_animator)
			{
				if ((Object)(object)___m_character != (Object)(object)Player.m_localPlayer || !___m_character.InAttack())
				{
					return;
				}
				Player val = (Player)(object)((___m_character is Player) ? ___m_character : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				ItemData currentWeapon = ((Humanoid)val).GetCurrentWeapon();
				if (currentWeapon != null && ModifierData.HasAnyModifiers(currentWeapon))
				{
					RuneEffectManager.WeaponModifiers weaponModifiers = RuneEffectManager.GetWeaponModifiers(currentWeapon);
					if (weaponModifiers.AttackSpeedPercent > 0f)
					{
						___m_animator.speed *= 1f + weaponModifiers.AttackSpeedPercent / 100f;
					}
					if (RuneEffectManager.MythicBerserkerPercent > 0f && ((Character)val).GetHealthPercentage() <= 0.3f)
					{
						___m_animator.speed *= 1f + RuneEffectManager.MythicBerserkerPercent / 100f;
					}
					RuneEffectManager.ToolModifiers toolModifiers = RuneEffectManager.GetToolModifiers(currentWeapon);
					if (toolModifiers.SwingSpeedPercent > 0f)
					{
						___m_animator.speed *= 1f + toolModifiers.SwingSpeedPercent / 100f;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "BlockAttack")]
		internal static class FrostShieldPatch
		{
			private static void Postfix(Humanoid __instance, HitData hit, bool __result)
			{
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: 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_00ef: 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_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				if (!__result || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || RuneEffectManager.MythicFrostSlowPercent <= 0f)
				{
					return;
				}
				Character attacker = hit.GetAttacker();
				if (!((Object)(object)attacker == (Object)null) && !((Object)(object)attacker == (Object)(object)__instance))
				{
					HitData val = new HitData();
					val.m_damage.m_frost = RuneEffectManager.MythicFrostSlowPercent;
					val.m_point = ((Component)attacker).transform.position;
					Vector3 val2 = ((Component)attacker).transform.position - ((Component)__instance).transform.position;
					val.m_dir = ((Vector3)(ref val2)).normalized;
					val.SetAttacker((Character)(object)__instance);
					attacker.Damage(val);
					ZNetScene instance = ZNetScene.instance;
					GameObject val3 = ((instance != null) ? instance.GetPrefab("vfx_ColdBall_launch") : null);
					if ((Object)(object)val3 != (Object)null)
					{
						Object.Instantiate<GameObject>(val3, ((Component)attacker).transform.position + Vector3.up, Quaternion.identity);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Skills), "RaiseSkill")]
		internal static class ToolMasteryPatch
		{
			private static void Prefix(SkillType skillType, ref float factor)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Invalid comparison between Unknown and I4
				if (!(RuneEffectManager.ToolMasteryPercent <= 0f) && ((int)skillType == 13 || (int)skillType == 12))
				{
					factor *= 1f + RuneEffectManager.ToolMasteryPercent / 100f;
				}
			}
		}

		[HarmonyPatch(typeof(Attack), "GetAttackStamina")]
		internal static class ToolStaminaPatch
		{
			private static void Postfix(Attack __instance, ref float __result)
			{
				Humanoid character = __instance.m_character;
				Player val = (Player)(object)((character is Player) ? character : null);
				if (val == null || (Object)(object)val != (Object)(object)Player.m_localPlayer)
				{
					return;
				}
				ItemData weapon = __instance.m_weapon;
				if (weapon != null && ModifierData.HasAnyModifiers(weapon))
				{
					RuneEffectManager.ToolModifiers toolModifiers = RuneEffectManager.GetToolModifiers(weapon);
					if (toolModifiers.StaminaReductionPercent > 0f)
					{
						__result *= 1f - Mathf.Clamp01(toolModifiers.StaminaReductionPercent / 100f);
					}
					RuneEffectManager.WeaponModifiers weaponModifiers = RuneEffectManager.GetWeaponModifiers(weapon);
					if (weaponModifiers.DamagePercent > 0f)
					{
						__result *= 1.05f;
					}
				}
			}
		}

		[HarmonyPatch(typeof(ItemData), "GetBlockPower", new Type[]
		{
			typeof(int),
			typeof(float)
		})]
		internal static class ShieldBlockPowerPatch
		{
			internal static bool IsParrying;

			private static void Postfix(ItemData __instance, ref float __result)
			{
				if (ModifierData.HasAnyModifiers(__instance))
				{
					RuneEffectManager.ShieldModifiers shieldModifiers = RuneEffectManager.GetShieldModifiers(__instance);
					if (shieldModifiers.FortressPercent > 0f)
					{
						__result *= 1f + shieldModifiers.FortressPercent / 100f;
					}
					if (IsParrying && shieldModifiers.ParryBonusPercent > 0f)
					{
						__result *= 1f + shieldModifiers.ParryBonusPercent / 100f;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "BlockAttack")]
		internal static class ShieldBlockAttackPatch
		{
			private static bool _wasParry;

			private static void Prefix(Humanoid __instance)
			{
				if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
				{
					_wasParry = __instance.m_blockTimer != -1f;
					ShieldBlockPowerPatch.IsParrying = _wasParry;
				}
			}

			private static void Postfix(Humanoid __instance, HitData hit, bool __result)
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Invalid comparison between Unknown and I4
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Expected O, but got Unknown
				//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_00cf: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
				ShieldBlockPowerPatch.IsParrying = false;
				if (!__result || (Object)(object)__instance != (Object)(object)Player.m_localPlayer)
				{
					return;
				}
				ItemData leftItem = __instance.m_leftItem;
				if (leftItem == null || (int)leftItem.m_shared.m_itemType != 5 || !ModifierData.HasAnyModifiers(leftItem))
				{
					return;
				}
				RuneEffectManager.ShieldModifiers shieldModifiers = RuneEffectManager.GetShieldModifiers(leftItem);
				Character attacker = hit.GetAttacker();
				if (shieldModifiers.ThornsDamage > 0f && (Object)(object)attacker != (Object)null && (Object)(object)attacker != (Object)(object)__instance)
				{
					HitData val = new HitData();
					val.m_damage.m_blunt = shieldModifiers.ThornsDamage;
					val.m_point = ((Component)attacker).transform.position;
					Vector3 val2 = ((Component)attacker).transform.position - ((Component)__instance).transform.position;
					val.m_dir = ((Vector3)(ref val2)).normalized;
					val.SetAttacker((Character)(object)__instance);
					attacker.Damage(val);
				}
				if (shieldModifiers.ResilienceStamina > 0f && _wasParry)
				{
					Player val3 = (Player)(object)((__instance is Player) ? __instance : null);
					if (val3 != null)
					{
						((Character)val3).AddStamina(shieldModifiers.ResilienceStamina);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "GetSkillFactor")]
		internal static class WeaponSkillPatch
		{
			private static void Postfix(Player __instance, SkillType skill, ref float __result)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)__instance == (Object)null))
				{
					AddSkillBonusFromItem(((Humanoid)__instance).m_rightItem, skill, ref __result);
					AddSkillBonusFromItem(((Humanoid)__instance).m_leftItem, skill, ref __result);
				}
			}

			private static void AddSkillBonusFromItem(ItemData item, SkillType skill, ref float result)
			{
				//IL_001c: 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)
				if (item != null && ModifierData.HasAnyModifiers(item) && item.m_shared.m_skillType == skill)
				{
					RuneEffectManager.WeaponModifiers weaponModifiers = RuneEffectManager.GetWeaponModifiers(item);
					if (weaponModifiers.SkillBonus > 0f)
					{
						result += weaponModifiers.SkillBonus / 100f;
					}
				}
			}
		}

		public static void Register(Harmony harmony)
		{
			TryPatch(harmony, typeof(WeaponDamagePatch));
			TryPatch(harmony, typeof(ArmorBonusPatch));
			TryPatch(harmony, typeof(HitModifierPatch));
			TryPatch(harmony, typeof(DamageResistancePatch));
			TryPatch(harmony, typeof(AttackSpeedPatch));
			TryPatch(harmony, typeof(PlayerUpdatePatch));
			TryPatch(harmony, typeof(NoiseReductionPatch));
			TryPatch(harmony, typeof(CombatPatch));
			TryPatch(harmony, typeof(FoodValueBonusPatch));
			TryPatch(harmony, typeof(StaminaRegenPatch));
			TryPatch(harmony, typeof(HealthRegenPatch));
			TryPatch(harmony, typeof(EitrRegenPatch));
			TryPatch(harmony, typeof(MoveSpeedPatch));
			TryPatch(harmony, typeof(CarryWeightPatch));
			TryPatch(harmony, typeof(StaggerResistPatch));
			TryPatch(harmony, typeof(DurabilityPatch));
			TryPatch(harmony, typeof(ExplorerPatch));
			TryPatch(harmony, typeof(ValhallaPatch));
			TryPatch(harmony, typeof(UndyingPatch));
			TryPatch(harmony, typeof(FrostShieldPatch));
			TryPatch(harmony, typeof(ToolMasteryPatch));
			TryPatch(harmony, typeof(ToolStaminaPatch));
			TryPatch(harmony, typeof(ShieldBlockPowerPatch));
			TryPatch(harmony, typeof(ShieldBlockAttackPatch));
			TryPatch(harmony, typeof(WeaponSkillPatch));
		}

		private static void TryPatch(Harmony harmony, Type patchClass)
		{
			try
			{
				harmony.CreateClassProcessor(patchClass).Patch();
				Logger.LogInfo((object)("StatPatch applied: " + patchClass.Name));
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("StatPatch skipped " + patchClass.Name + ": " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(Player), "UseStamina")]
	internal static class OutOfCombatStaminaPatch
	{
		private static readonly HashSet<string> IgnoredCreatures = new HashSet<string> { "Deer" };

		private const float CombatRange = 25f;

		private const float IgnoredCreatureCombatRange = 10f;

		private const float CacheInterval = 1f;

		private static float _lastCheckTime;

		private static bool _lastResult;

		private static readonly float CombatRangeSqr = 625f;

		private static readonly float IgnoredRangeSqr = 100f;

		public static void Register(Harmony harmony)
		{
			try
			{
				harmony.CreateClassProcessor(typeof(OutOfCombatStaminaPatch)).Patch();
				Logger.LogInfo((object)"Patch applied: OutOfCombatStaminaPatch");
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)("Patch skipped OutOfCombatStaminaPatch: " + ex.Message));
			}
		}

		private static void Prefix(ref Player __instance, ref float v)
		{
			if (ModConfig.EnableOutOfCombatStamina.Value)
			{
				float time = Time.time;
				if (time - _lastCheckTime > 1f)
				{
					_lastCheckTime = time;
					_lastResult = __instance.IsSensed() || IsTargetedByHostile(__instance);
				}
				if (!_lastResult)
				{
					v = 0f;
				}
			}
		}

		private static bool IsTargetedByHostile(Player player)
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)player).transform.position;
			foreach (BaseAI instance in BaseAI.Instances)
			{
				BaseAI val = instance;
				if ((Object)(object)val == (Object)null || (Object)(object)val.GetTargetCreature() != (Object)(object)player)
				{
					continue;
				}
				Vector3 val2 = ((Component)val).transform.position - position;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				string prefabName = Utils.GetPrefabName(((Component)val).gameObject);
				if (IgnoredCreatures.Contains(prefabName))
				{
					if (sqrMagnitude <= IgnoredRangeSqr)
					{
						return true;
					}
				}
				else if (sqrMagnitude <= CombatRangeSqr)
				{
					return true;
				}
			}
			return false;
		}
	}
}
namespace RunesOfRefinement.Systems
{
	public enum ItemRarity
	{
		Normal,
		Magic,
		Rare
	}
	public static class RarityHelper
	{
		public static readonly Color NormalColor = Color.white;

		public static readonly Color MagicColor = new Color(0.53f, 0.81f, 0.98f);

		public static readonly Color RareColor = new Color(1f, 0.95f, 0.3f);

		public static readonly Color CorruptedColor = new Color(0.85f, 0.2f, 0.2f);

		public static Color GetColor(ItemRarity rarity)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(rarity switch
			{
				ItemRarity.Magic => MagicColor, 
				ItemRarity.Rare => RareColor, 
				_ => NormalColor, 
			});
		}

		public static int MaxPrefixes(ItemRarity rarity)
		{
			return rarity switch
			{
				ItemRarity.Magic => 1, 
				ItemRarity.Rare => 3, 
				_ => 0, 
			};
		}

		public static int MaxSuffixes(ItemRarity rarity)
		{
			return rarity switch
			{
				ItemRarity.Magic => 1, 
				ItemRarity.Rare => 3, 
				_ => 0, 
			};
		}

		public static int MaxAffixSlots(ItemRarity rarity)
		{
			return MaxPrefixes(rarity) + MaxSuffixes(rarity);
		}
	}
	public enum AffixTarget
	{
		Weapon,
		Armor,
		Tool,
		Shield,
		Any
	}
	public enum AffixCategory
	{
		Offensive,
		Defensive,
		Utility,
		Elemental,
		Mythic
	}
	public enum AffixSlot
	{
		Prefix,
		Suffix
	}
	public class AffixDefinition
	{
		public string Id;

		public string NameToken;

		public string DescToken;

		public AffixTarget Target;

		public AffixCategory Category;

		public AffixSlot Slot;

		public float MinValue;

		public float MaxValue;

		public bool IsMythic;
	}
	public class RolledAffix
	{
		public string AffixId;

		public float Value;

		public override string ToString()
		{
			return AffixId + ":" + Value.ToString("F2", CultureInfo.InvariantCulture);
		}

		public static RolledAffix Parse(string s)
		{
			string[] array = s.Split(new char[1] { ':' });
			return new RolledAffix
			{
				AffixId = array[0],
				Value = float.Parse(array[1], CultureInfo.InvariantCulture)
			};
		}
	}
	public static class AffixPool
	{
		private static readonly Random Rng = new Random();

		internal static readonly float[][] TierScale = new float[6][]
		{
			new float[2] { 0f, 0.25f },
			new float[2] { 0.15f, 0.4f },
			new float[2] { 0.3f, 0.55f },
			new float[2] { 0.45f, 0.7f },
			new float[2] { 0.6f, 0.85f },
			new float[2] { 0.8f, 1f }
		};

		public static readonly List<AffixDefinition> All = new List<AffixDefinition>
		{
			new AffixDefinition
			{
				Id = "heavy_blade",
				NameToken = "$affix_heavy_blade",
				DescToken = "$affix_heavy_blade_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Offensive,
				Slot = AffixSlot.Prefix,
				MinValue = 3f,
				MaxValue = 10f
			},
			new AffixDefinition
			{
				Id = "armor_pierce",
				NameToken = "$affix_armor_pierce",
				DescToken = "$affix_armor_pierce_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Offensive,
				Slot = AffixSlot.Prefix,
				MinValue = 2f,
				MaxValue = 8f
			},
			new AffixDefinition
			{
				Id = "crit_strike",
				NameToken = "$affix_crit_strike",
				DescToken = "$affix_crit_strike_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Offensive,
				Slot = AffixSlot.Prefix,
				MinValue = 3f,
				MaxValue = 12f
			},
			new AffixDefinition
			{
				Id = "backstab_bonus",
				NameToken = "$affix_backstab_bonus",
				DescToken = "$affix_backstab_bonus_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Offensive,
				Slot = AffixSlot.Prefix,
				MinValue = 10f,
				MaxValue = 40f
			},
			new AffixDefinition
			{
				Id = "elem_fire",
				NameToken = "$affix_elem_fire",
				DescToken = "$affix_elem_fire_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Elemental,
				Slot = AffixSlot.Prefix,
				MinValue = 3f,
				MaxValue = 15f
			},
			new AffixDefinition
			{
				Id = "elem_frost",
				NameToken = "$affix_elem_frost",
				DescToken = "$affix_elem_frost_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Elemental,
				Slot = AffixSlot.Prefix,
				MinValue = 3f,
				MaxValue = 15f
			},
			new AffixDefinition
			{
				Id = "elem_lightning",
				NameToken = "$affix_elem_lightning",
				DescToken = "$affix_elem_lightning_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Elemental,
				Slot = AffixSlot.Prefix,
				MinValue = 3f,
				MaxValue = 15f
			},
			new AffixDefinition
			{
				Id = "elem_poison",
				NameToken = "$affix_elem_poison",
				DescToken = "$affix_elem_poison_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Elemental,
				Slot = AffixSlot.Prefix,
				MinValue = 3f,
				MaxValue = 15f
			},
			new AffixDefinition
			{
				Id = "elem_spirit",
				NameToken = "$affix_elem_spirit",
				DescToken = "$affix_elem_spirit_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Elemental,
				Slot = AffixSlot.Prefix,
				MinValue = 3f,
				MaxValue = 15f
			},
			new AffixDefinition
			{
				Id = "swift",
				NameToken = "$affix_swift",
				DescToken = "$affix_swift_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Offensive,
				Slot = AffixSlot.Suffix,
				MinValue = 1f,
				MaxValue = 5f
			},
			new AffixDefinition
			{
				Id = "warrior_of_north",
				NameToken = "$affix_warrior_of_north",
				DescToken = "$affix_warrior_of_north_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 2f,
				MaxValue = 8f
			},
			new AffixDefinition
			{
				Id = "bloodthirsty",
				NameToken = "$affix_bloodthirsty",
				DescToken = "$affix_bloodthirsty_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 1f,
				MaxValue = 4f
			},
			new AffixDefinition
			{
				Id = "momentum",
				NameToken = "$affix_momentum",
				DescToken = "$affix_momentum_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 3f,
				MaxValue = 10f
			},
			new AffixDefinition
			{
				Id = "knockback",
				NameToken = "$affix_knockback",
				DescToken = "$affix_knockback_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Offensive,
				Slot = AffixSlot.Suffix,
				MinValue = 10f,
				MaxValue = 40f
			},
			new AffixDefinition
			{
				Id = "hardened",
				NameToken = "$affix_hardened",
				DescToken = "$affix_hardened_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Defensive,
				Slot = AffixSlot.Prefix,
				MinValue = 2f,
				MaxValue = 8f
			},
			new AffixDefinition
			{
				Id = "fortified",
				NameToken = "$affix_fortified",
				DescToken = "$affix_fortified_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Defensive,
				Slot = AffixSlot.Prefix,
				MinValue = 5f,
				MaxValue = 25f
			},
			new AffixDefinition
			{
				Id = "frost_resist",
				NameToken = "$affix_frost_resist",
				DescToken = "$affix_frost_resist_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Defensive,
				Slot = AffixSlot.Prefix,
				MinValue = 5f,
				MaxValue = 30f
			},
			new AffixDefinition
			{
				Id = "fire_resist",
				NameToken = "$affix_fire_resist",
				DescToken = "$affix_fire_resist_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Defensive,
				Slot = AffixSlot.Prefix,
				MinValue = 5f,
				MaxValue = 30f
			},
			new AffixDefinition
			{
				Id = "poison_resist",
				NameToken = "$affix_poison_resist",
				DescToken = "$affix_poison_resist_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Defensive,
				Slot = AffixSlot.Prefix,
				MinValue = 5f,
				MaxValue = 30f
			},
			new AffixDefinition
			{
				Id = "unfazed",
				NameToken = "$affix_unfazed",
				DescToken = "$affix_unfazed_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Defensive,
				Slot = AffixSlot.Prefix,
				MinValue = 5f,
				MaxValue = 20f
			},
			new AffixDefinition
			{
				Id = "sturdy_build",
				NameToken = "$affix_sturdy_build",
				DescToken = "$affix_sturdy_build_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 5f,
				MaxValue = 20f
			},
			new AffixDefinition
			{
				Id = "regeneration",
				NameToken = "$affix_regeneration",
				DescToken = "$affix_regeneration_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 3f,
				MaxValue = 12f
			},
			new AffixDefinition
			{
				Id = "stealth",
				NameToken = "$affix_stealth",
				DescToken = "$affix_stealth_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 5f,
				MaxValue = 15f
			},
			new AffixDefinition
			{
				Id = "sprinter",
				NameToken = "$affix_sprinter",
				DescToken = "$affix_sprinter_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 2f,
				MaxValue = 8f
			},
			new AffixDefinition
			{
				Id = "hp_regen",
				NameToken = "$affix_hp_regen",
				DescToken = "$affix_hp_regen_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Defensive,
				Slot = AffixSlot.Suffix,
				MinValue = 5f,
				MaxValue = 20f
			},
			new AffixDefinition
			{
				Id = "carry_weight",
				NameToken = "$affix_carry_weight",
				DescToken = "$affix_carry_weight_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 10f,
				MaxValue = 50f
			},
			new AffixDefinition
			{
				Id = "tool_mining",
				NameToken = "$affix_tool_mining",
				DescToken = "$affix_tool_mining_desc",
				Target = AffixTarget.Tool,
				Category = AffixCategory.Offensive,
				Slot = AffixSlot.Prefix,
				MinValue = 5f,
				MaxValue = 25f
			},
			new AffixDefinition
			{
				Id = "tool_chopping",
				NameToken = "$affix_tool_chopping",
				DescToken = "$affix_tool_chopping_desc",
				Target = AffixTarget.Tool,
				Category = AffixCategory.Offensive,
				Slot = AffixSlot.Prefix,
				MinValue = 5f,
				MaxValue = 25f
			},
			new AffixDefinition
			{
				Id = "tool_sharpened",
				NameToken = "$affix_tool_sharpened",
				DescToken = "$affix_tool_sharpened_desc",
				Target = AffixTarget.Tool,
				Category = AffixCategory.Offensive,
				Slot = AffixSlot.Prefix,
				MinValue = 3f,
				MaxValue = 15f
			},
			new AffixDefinition
			{
				Id = "tool_lightweight",
				NameToken = "$affix_tool_lightweight",
				DescToken = "$affix_tool_lightweight_desc",
				Target = AffixTarget.Tool,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 2f,
				MaxValue = 8f
			},
			new AffixDefinition
			{
				Id = "tool_mastery",
				NameToken = "$affix_tool_mastery",
				DescToken = "$affix_tool_mastery_desc",
				Target = AffixTarget.Tool,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 5f,
				MaxValue = 25f
			},
			new AffixDefinition
			{
				Id = "tool_efficient",
				NameToken = "$affix_tool_efficient",
				DescToken = "$affix_tool_efficient_desc",
				Target = AffixTarget.Tool,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 3f,
				MaxValue = 12f
			},
			new AffixDefinition
			{
				Id = "shield_fortress",
				NameToken = "$affix_shield_fortress",
				DescToken = "$affix_shield_fortress_desc",
				Target = AffixTarget.Shield,
				Category = AffixCategory.Defensive,
				Slot = AffixSlot.Prefix,
				MinValue = 5f,
				MaxValue = 20f
			},
			new AffixDefinition
			{
				Id = "shield_thorns",
				NameToken = "$affix_shield_thorns",
				DescToken = "$affix_shield_thorns_desc",
				Target = AffixTarget.Shield,
				Category = AffixCategory.Defensive,
				Slot = AffixSlot.Prefix,
				MinValue = 3f,
				MaxValue = 12f
			},
			new AffixDefinition
			{
				Id = "shield_parry",
				NameToken = "$affix_shield_parry",
				DescToken = "$affix_shield_parry_desc",
				Target = AffixTarget.Shield,
				Category = AffixCategory.Defensive,
				Slot = AffixSlot.Prefix,
				MinValue = 10f,
				MaxValue = 30f
			},
			new AffixDefinition
			{
				Id = "shield_aegis",
				NameToken = "$affix_shield_aegis",
				DescToken = "$affix_shield_aegis_desc",
				Target = AffixTarget.Shield,
				Category = AffixCategory.Defensive,
				Slot = AffixSlot.Suffix,
				MinValue = 2f,
				MaxValue = 8f
			},
			new AffixDefinition
			{
				Id = "shield_resilience",
				NameToken = "$affix_shield_resilience",
				DescToken = "$affix_shield_resilience_desc",
				Target = AffixTarget.Shield,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 3f,
				MaxValue = 10f
			},
			new AffixDefinition
			{
				Id = "shield_bulwark",
				NameToken = "$affix_shield_bulwark",
				DescToken = "$affix_shield_bulwark_desc",
				Target = AffixTarget.Shield,
				Category = AffixCategory.Defensive,
				Slot = AffixSlot.Suffix,
				MinValue = 2f,
				MaxValue = 8f
			},
			new AffixDefinition
			{
				Id = "durability",
				NameToken = "$affix_durability",
				DescToken = "$affix_durability_desc",
				Target = AffixTarget.Any,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 50f,
				MaxValue = 200f
			},
			new AffixDefinition
			{
				Id = "eitr_regen",
				NameToken = "$affix_eitr_regen",
				DescToken = "$affix_eitr_regen_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 5f,
				MaxValue = 20f
			},
			new AffixDefinition
			{
				Id = "explorer",
				NameToken = "$affix_explorer",
				DescToken = "$affix_explorer_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Utility,
				Slot = AffixSlot.Suffix,
				MinValue = 5f,
				MaxValue = 25f
			},
			new AffixDefinition
			{
				Id = "mythic_lightning_strike",
				NameToken = "$affix_mythic_lightning",
				DescToken = "$affix_mythic_lightning_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Mythic,
				Slot = AffixSlot.Prefix,
				MinValue = 3f,
				MaxValue = 7f,
				IsMythic = true
			},
			new AffixDefinition
			{
				Id = "mythic_frost_shield",
				NameToken = "$affix_mythic_frost_shield",
				DescToken = "$affix_mythic_frost_shield_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Mythic,
				Slot = AffixSlot.Prefix,
				MinValue = 20f,
				MaxValue = 40f,
				IsMythic = true
			},
			new AffixDefinition
			{
				Id = "mythic_heimdall",
				NameToken = "$affix_mythic_heimdall",
				DescToken = "$affix_mythic_heimdall_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Mythic,
				Slot = AffixSlot.Prefix,
				MinValue = 8f,
				MaxValue = 15f,
				IsMythic = true
			},
			new AffixDefinition
			{
				Id = "mythic_undying",
				NameToken = "$affix_mythic_undying",
				DescToken = "$affix_mythic_undying_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Mythic,
				Slot = AffixSlot.Prefix,
				MinValue = 15f,
				MaxValue = 30f,
				IsMythic = true
			},
			new AffixDefinition
			{
				Id = "mythic_berserker",
				NameToken = "$affix_mythic_berserker",
				DescToken = "$affix_mythic_berserker_desc",
				Target = AffixTarget.Weapon,
				Category = AffixCategory.Mythic,
				Slot = AffixSlot.Prefix,
				MinValue = 5f,
				MaxValue = 12f,
				IsMythic = true
			},
			new AffixDefinition
			{
				Id = "mythic_valhalla",
				NameToken = "$affix_mythic_valhalla",
				DescToken = "$affix_mythic_valhalla_desc",
				Target = AffixTarget.Armor,
				Category = AffixCategory.Mythic,
				Slot = AffixSlot.Prefix,
				MinValue = 3f,
				MaxValue = 8f,
				IsMythic = true
			}
		};

		public static AffixDefinition Get(string id)
		{
			return All.FirstOrDefault((AffixDefinition a) => a.Id == id);
		}

		public static RolledAffix RollRandom(AffixTarget target, AffixSlot? slotConstraint = null, AffixCategory? forceCategory = null, HashSet<string> exclude = null, int tier = 6)
		{
			List<AffixDefinition> list = All.Where((AffixDefinition a) => !a.IsMythic && (a.Target == target || a.Target == AffixTarget.Any || (target == AffixTarget.Tool && a.Target == AffixTarget.Weapon) || (target == AffixTarget.Shield && a.Target == AffixTarget.Armor)) && (!slotConstraint.HasValue || a.Slot == slotConstraint) && (!forceCategory.HasValue || a.Category == forceCategory) && (exclude == null || !exclude.Contains(a.Id))).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			AffixDefinition def = list[Rng.Next(list.Count)];
			return Roll(def, tier);
		}

		public static RolledAffix RollWithLimits(AffixTarget target, int curPrefixes, int maxPrefixes, int curSuffixes, int maxSuffixes, AffixCategory? forceCategory = null, HashSet<string> exclude = null, int tier = 6)
		{
			bool flag = curPrefixes < maxPrefixes;
			bool flag2 = curSuffixes < maxSuffixes;
			if (!flag && !flag2)
			{
				return null;
			}
			AffixSlot? slotConstraint = null;
			if (flag && !flag2)
			{
				slotConstraint = AffixSlot.Prefix;
			}
			else if (flag2 && !flag)
			{
				slotConstraint = AffixSlot.Suffix;
			}
			return RollRandom(target, slotConstraint, forceCategory, exclude, tier);
		}

		public static RolledAffix RollElemental(AffixTarget target, int tier = 6)
		{
			return RollRandom(target, null, AffixCategory.Elemental, null, tier);
		}

		public static int CountPrefixes(List<RolledAffix> affixes)
		{
			return affixes.Count(delegate(RolledAffix a)
			{
				AffixDefinition affixDefinition = Get(a.AffixId);
				return affixDefinition != null && affixDefinition.Slot == AffixSlot.Prefix;
			});
		}

		public static int CountSuffixes(List<RolledAffix> affixes)
		{
			return affixes.Count(delegate(RolledAffix a)
			{
				AffixDefinition affixDefinition = Get(a.AffixId);
				return affixDefinition != null && affixDefinition.Slot == AffixSlot.Suffix;
			});
		}

		public static RolledAffix RollMythic(AffixTarget target, int tier = 6)
		{
			List<AffixDefinition> list = All.Where((AffixDefinition a) => a.IsMythic && (a.Target == target || a.Target == AffixTarget.Any || (target == AffixTarget.Tool && a.Target == AffixTarget.Weapon) || (target == AffixTarget.Shield && a.Target == AffixTarget.Armor))).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			AffixDefinition def = list[Rng.Next(list.Count)];
			return Roll(def, tier);
		}

		public static RolledAffix RerollValue(RolledAffix existing, int tier = 6)
		{
			AffixDefinition affixDefinition = Get(existing.AffixId);
			if (affixDefinition == null)
			{
				return existing;
			}
			return Roll(affixDefinition, tier);
		}

		public static RolledAffix MaxRollValue(RolledAffix existing, int tier = 6)
		{
			AffixDefinition affixDefinition = Get(existing.AffixId);
			if (affixDefinition == null)
			{
				return existing;
			}
			tier = Mathf.Clamp(tier, 1, 6);
			float num = affixDefinition.MaxValue - affixDefinition.MinValue;
			float num2 = affixDefinition.MinValue + num * TierScale[tier - 1][1];
			num2 = Mathf.Round(num2 * 10f) / 10f;
			return new RolledAffix
			{
				AffixId = affixDefinition.Id,
				Value = num2
			};
		}

		public static string GetRollQualityColor(RolledAffix affix)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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_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)
			//IL_0170: 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_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: 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_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			AffixDefinition affixDefinition = Get(affix.AffixId);
			if (affixDefinition == null)
			{
				return "#CCCCCC";
			}
			float num = affixDefinition.MaxValue - affixDefinition.MinValue;
			float num2 = ((num > 0f) ? Mathf.Clamp01((affix.Value - affixDefinition.MinValue) / num) : 0.5f);
			Color val;
			if (num2 < 0.25f)
			{
				float num3 = num2 / 0.25f;
				val = Color.Lerp(new Color(0.55f, 0.55f, 0.55f), Color.white, num3);
			}
			else if (num2 < 0.5f)
			{
				float num4 = (num2 - 0.25f) / 0.25f;
				val = Color.Lerp(Color.white, new Color(0.4f, 1f, 0.6f), num4);
			}
			else if (num2 < 0.75f)
			{
				float num5 = (num2 - 0.5f) / 0.25f;
				val = Color.Lerp(new Color(0.4f, 1f, 0.6f), new Color(0.4f, 0.7f, 1f), num5);
			}
			else
			{
				float num6 = (num2 - 0.75f) / 0.25f;
				val = Color.Lerp(new Color(0.4f, 0.7f, 1f), new Color(1f, 0.85f, 0.3f), num6);
			}
			return "#" + ColorUtility.ToHtmlStringRGB(val);
		}

		private static RolledAffix Roll(AffixDefinition def, int tier = 6)
		{
			tier = Mathf.Clamp(tier, 1, 6);
			float num = def.MaxValue - def.MinValue;
			float num2 = def.MinValue + num * TierScale[tier - 1][0];
			float num3 = def.MinValue + num * TierScale[tier - 1][1];
			float num4 = (float)((double)num2 + Rng.NextDouble() * (double)(num3 - num2));
			num4 = Mathf.Round(num4 * 10f) / 10f;
			return new RolledAffix
			{
				AffixId = def.Id,
				Value = num4
			};
		}
	}
	public static class ModifierData
	{
		private const string KeyRarity = "ror_rarity";

		private const string KeyAffixCount = "ror_affix_count";

		private const string KeyAffixPrefix = "ror_affix_";

		private const string KeyMythicAffix = "ror_mythic_affix";

		private const string KeyCorrupted = "ror_corrupted";

		public static ItemRarity GetRarity(ItemData item)
		{
			if (item.m_customData.TryGetValue("ror_rarity", out var value))
			{
				switch (value)
				{
				case "magic":
					return ItemRarity.Magic;
				case "rare":
					return ItemRarity.Rare;
				case "mythic":
					return ItemRarity.Rare;
				}
			}
			return ItemRarity.Normal;
		}

		public static void SetRarity(ItemData item, ItemRarity rarity)
		{
			switch (rarity)
			{
			case ItemRarity.Magic:
				item.m_customData["ror_rarity"] = "magic";
				break;
			case ItemRarity.Rare:
				item.m_customData["ror_rarity"] = "rare";
				break;
			default:
				item.m_customData["ror_rarity"] = "normal";
				break;
			}
		}

		public static List<RolledAffix> GetAffixes(ItemData item)
		{
			List<RolledAffix> list = new List<RolledAffix>();
			if (!item.m_customData.TryGetValue("ror_affix_count", out var value))
			{
				return list;
			}
			if (!int.TryParse(value, out var result))
			{
				return list;
			}
			for (int i = 0; i < result; i++)
			{
				if (item.m_customData.TryGetValue("ror_affix_" + i, out var value2))
				{
					list.Add(RolledAffix.Parse(value2));
				}
			}
			return list;
		}

		public static void SetAffixes(ItemData item, List<RolledAffix> affixes)
		{
			if (item.m_customData.TryGetValue("ror_affix_count", out var value) && int.TryParse(value, out var result))
			{
				for (int i = 0; i < result; i++)
				{
					item.m_customData.Remove("ror_affix_" + i);
				}
			}
			item.m_customData["ror_affix_count"] = affixes.Count.ToString();
			for (int j = 0; j < affixes.Count; j++)
			{
				item.m_customData["ror_affix_" + j] = affixes[j].ToString();
			}
		}

		public static RolledAffix GetMythicAffix(ItemData item)
		{
			if (item.m_customData.TryGetValue("ror_mythic_affix", out var value))
			{
				return RolledAffix.Parse(value);
			}
			return null;
		}

		public static void SetMythicAffix(ItemData item, RolledAffix affix)
		{
			item.m_customData["ror_mythic_affix"] = affix.ToString();
		}

		public static bool IsCorrupted(ItemData item)
		{
			return item.m_customData.ContainsKey("ror_corrupted");
		}

		public static void SetCorrupted(ItemData item, bool corrupted)
		{
			if (corrupted)
			{
				item.m_customData["ror_corrupted"] = "1";
			}
			else
			{
				item.m_customData.Remove("ror_corrupted");
			}
		}

		public static bool HasAnyModifiers(ItemData item)
		{
			return item.m_customData.ContainsKey("ror_rarity");
		}
	}
	public static class RuneEffectManager
	{
		public class WeaponModifiers
		{
			public float DamagePercent;

			public float AttackSpeedPercent;

			public float ArmorIgnore;

			public float SkillBonus;

			public float LifestealPercent;

			public float FireDamage;

			public float FrostDamage;

			public float LightningDamage;

			public float PoisonDamage;

			public float SpiritDamage;

			public float CritStrikePercent;

			public float BackstabBonusPercent;

			public float KnockbackPercent;

			public float StaminaOnKill;

			public float DurabilityBonus;

			public float LightningStrikeChance;

			public float HeimdallDamagePercent;

			public float BerserkerPercent;
		}

		public class ToolModifiers
		{
			public float MiningPercent;

			public float ChoppingPercent;

			public float ToolDamagePercent;

			public float SwingSpeedPercent;

			public float MasteryPercent;

			public float StaminaReductionPercent;

			public float DurabilityBonus;
		}

		public class ShieldModifiers
		{
			public float FortressPercent;

			public float ThornsDamage;

			public float ParryBonusPercent;

			public float AegisPercent;

			public float ResilienceStamina;

			public float BulwarkArmor;

			public float DurabilityBonus;
		}

		private static float _bonusDamagePercent;

		private static float _armorIgnore;

		private static float _attackSpeedPercent;

		private static float _lifestealPercent;

		private static float _weaponSkillBonus;

		private static float _fireDamage;

		private static float _frostDamage;

		private static float _lightningDamage;

		private static float _poisonDamage;

		private static float _spiritDamage;

		private static float _critStrikePercent;

		private static float _backstabBonusPercent;

		private static float _knockbackPercent;

		private static float _staminaOnKill;

		private static float _bonusArmorFlat;

		private static float _maxStaminaBonus;

		private static float _staminaRegenPercent;

		private static float _noiseReductionPercent;

		private static float _maxHealthBonus;

		private static float _frostResistance;

		private static float _fireResistance;

		private static float _poisonResistance;

		private static float _staggerResistPercent;

		private static float _moveSpeedPercent;

		private static float _hpRegenPercent;

		private static float _carryWeightBonus;

		private static float _durabilityBonus;

		private static float _eitrRegenPercent;

		private static float _explorerPercent;

		private static float _mythicLightningChance;

		private static float _mythicFrostSlowPercent;

		private static float _mythicHeimdallDamagePercent;

		private static float _mythicUndyingPercent;

		private static float _mythicBerserkerPercent;

		private static float _mythicValhallaXpPercent;

		private static float _toolMiningPercent;

		private static float _toolChoppingPercent;

		private static float _toolDamagePercent;

		private static float _toolSwingSpeedPercent;

		private static float _toolMasteryPercent;

		private static float _toolEfficiencyPercent;

		private static float _shieldFortressPercent;

		private static float _shieldThorns;

		private static float _shieldParryPercent;

		private static float _shieldAegisPercent;

		private static float _shieldResilienceStamina;

		private static float _shieldBulwarkArmor;

		private static int _lastEquipHash;

		public static float BonusDamagePercent => _bonusDamagePercent;

		public static float BonusArmorFlat => _bonusArmorFlat;

		public static float ArmorIgnore => _armorIgnore;

		public static float AttackSpeedPercent => _attackSpeedPercent;

		public static float LifestealPercent => _lifestealPercent;

		public static float WeaponSkillBonus => _weaponSkillBonus;

		public static float MaxStaminaBonus => _maxStaminaBonus;

		public static float StaminaRegenPercent => _staminaRegenPercent;

		public static float NoiseReductionPercent => _noiseReductionPercent;

		public static float MaxHealthBonus => _maxHealthBonus;

		public static float FrostResistance => _frostResistance;

		public static float FireResistance => _fireResistance;

		public static float PoisonResistance => _poisonResistance;

		public static float FireDamage => _fireDamage;

		public static float FrostDamage => _frostDamage;

		public static float LightningDamage => _lightningDamage;

		public static float PoisonDamage => _poisonDamage;

		public static float SpiritDamage => _spiritDamage;

		public static float CritStrikePercent => _critStrikePercent;

		public static float BackstabBonusPercent => _backstabBonusPercent;

		public static float KnockbackPercent => _knockbackPercent;

		public static float StaminaOnKill => _staminaOnKill;

		public static float StaggerResistPercent => _staggerResistPercent;

		public static float MoveSpeedPercent => _moveSpeedPercent;

		public static float HpRegenPercent => _hpRegenPercent;

		public static float CarryWeightBonus => _carryWeightBonus;

		public static float DurabilityBonus => _durabilityBonus;

		public static float EitrRegenPercent => _eitrRegenPercent;

		public static float ExplorerPercent => _explorerPercent;

		public static float MythicLightningChance => _mythicLightningChance;

		public static float MythicFrostSlowPercent => _mythicFrostSlowPercent;

		public static float MythicHeimdallDamagePercent => _mythicHeimdallDamagePercent;

		public static float MythicUndyingPercent => _mythicUndyingPercent;

		public static float MythicBerserkerPercent => _mythicBerserkerPercent;

		public static float MythicValhallaXpPercent => _mythicValhallaXpPercent;

		public static float ToolMiningPercent => _toolMiningPercent;

		public static float ToolChoppingPercent => _toolChoppingPercent;

		public static float ToolDamagePercent => _toolDamagePercent;

		public static float ToolSwingSpeedPercent => _toolSwingSpeedPercent;

		public static float ToolMasteryPercent => _toolMasteryPercent;

		public static float ToolEfficiencyPercent => _toolEfficiencyPercent;

		public static float ShieldFortressPercent => _shieldFortressPercent;

		public static float ShieldThorns => _shieldThorns;

		public static float ShieldParryPercent => _shieldParryPercent;

		public static float ShieldAegisPercent => _shieldAegisPercent;

		public static float ShieldResilienceStamina => _shieldResilienceStamina;

		public static float ShieldBulwarkArmor => _shieldBulwarkArmor;

		public static WeaponModifiers GetWeaponModifiers(ItemData weapon)
		{
			WeaponModifiers weaponModifiers = new WeaponModifiers();
			if (weapon == null || !ModifierData.HasAnyModifiers(weapon))
			{
				return weaponModifiers;
			}
			foreach (RolledAffix affix in ModifierData.GetAffixes(weapon))
			{
				switch (affix.AffixId)
				{
				case "heavy_blade":
					weaponModifiers.DamagePercent += affix.Value;
					break;
				case "swift":
					weaponModifiers.AttackSpeedPercent += affix.Value;
					break;
				case "armor_pierce":
					weaponModifiers.ArmorIgnore += affix.Value;
					break;
				case "warrior_of_north":
					weaponModifiers.SkillBonus += affix.Value;
					break;
				case "bloodthirsty":
					weaponModifiers.LifestealPercent += affix.Value;
					break;
				case "elem_fire":
					weaponModifiers.FireDamage += affix.Value;
					break;
				case "elem_frost":
					weaponModifiers.FrostDamage += affix.Value;
					break;
				case "elem_lightning":
					weaponModifiers.LightningDamage += affix.Value;
					break;
				case "elem_poison":
					weaponModifiers.PoisonDamage += affix.Value;
					break;
				case "elem_spirit":
					weaponModifiers.SpiritDamage += affix.Value;
					break;
				case "crit_strike":
					weaponModifiers.CritStrikePercent += affix.Value;
					break;
				case "backstab_bonus":
					weaponModifiers.BackstabBonusPercent += affix.Value;
					break;
				case "knockback":
					weaponModifiers.KnockbackPercent += affix.Value;
					break;
				case "momentum":
					weaponModifiers.StaminaOnKill += affix.Value;
					break;
				case "durability":
					weaponModifiers.DurabilityBonus += affix.Value;
					break;
				}
			}
			RolledAffix mythicAffix = ModifierData.GetMythicAffix(weapon);
			if (mythicAffix != null)
			{
				switch (mythicAffix.AffixId)
				{
				case "mythic_lightning_strike":
					weaponModifiers.LightningStrikeChance = mythicAffix.Value;
					break;
				case "mythic_heimdall":
					weaponModifiers.HeimdallDamagePercent = mythicAffix.Value;
					break;
				case "mythic_berserker":
					weaponModifiers.BerserkerPercent = mythicAffix.Value;
					break;
				}
			}
			return weaponModifiers;
		}

		public static float GetArmorBonus(ItemData armor)
		{
			if (armor == null || !ModifierData.HasAnyModifiers(armor))
			{
				return 0f;
			}
			float num = 0f;
			foreach (RolledAffix affix in ModifierData.GetAffixes(armor))
			{
				if (affix.AffixId == "hardened")
				{
					num += affix.Value;
				}
				if (affix.AffixId == "shield_bulwark")
				{
					num += affix.Value;
				}
			}
			return num;
		}

		public static ToolModifiers GetToolModifiers(ItemData tool)
		{
			ToolModifiers toolModifiers = new ToolModifiers();
			if (tool == null || !ModifierData.HasAnyModifiers(tool))
			{
				return toolModifiers;
			}
			foreach (RolledAffix affix in ModifierData.GetAffixes(tool))
			{
				switch (affix.AffixId)
				{
				case "tool_mining":
					toolModifiers.MiningPercent += affix.Value;
					break;
				case "tool_chopping":
					toolModifiers.ChoppingPercent += affix.Value;
					break;
				case "tool_sharpened":
					toolModifiers.ToolDamagePercent += affix.Value;
					break;
				case "tool_lightweight":
					toolModifiers.SwingSpeedPercent += affix.Value;
					break;
				case "tool_mastery":
					toolModifiers.MasteryPercent += affix.Value;
					break;
				case "tool_efficient":
					toolModifiers.StaminaReductionPercent += affix.Value;
					break;
				case "durability":
					toolModifiers.DurabilityBonus += affix.Value;
					break;
				}
			}
			return toolModifiers;
		}

		public static ShieldModifiers GetShieldModifiers(ItemData shield)
		{
			ShieldModifiers shieldModifiers = new ShieldModifiers();
			if (shield == null || !ModifierData.HasAnyModifiers(shield))
			{
				return shieldModifiers;
			}
			foreach (RolledAffix affix in ModifierData.GetAffixes(shield))
			{
				switch (affix.AffixId)
				{
				case "shield_fortress":
					shieldModifiers.FortressPercent += affix.Value;
					break;
				case "shield_thorns":
					shieldModifiers.ThornsDamage += affix.Value;
					break;
				case "shield_parry":
					shieldModifiers.ParryBonusPercent += affix.Value;
					break;
				case "shield_aegis":
					shieldModifiers.AegisPercent += affix.Value;
					break;
				case "shield_resilience":
					shieldModifiers.ResilienceStamina += affix.Value;
					break;
				case "shield_bulwark":
					shieldModifiers.BulwarkArmor += affix.Value;
					break;
				case "durability":
					shieldModifiers.DurabilityBonus += affix.Value;
					break;
				}
			}
			return shieldModifiers;
		}

		public static void Recalculate(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			int num = ComputeEquipHash(player);
			if (num == _lastEquipHash)
			{
				return;
			}
			_lastEquipHash = num;
			_bonusDamagePercent = 0f;
			_bonusArmorFlat = 0f;
			_armorIgnore = 0f;
			_attackSpeedPercent = 0f;
			_lifestealPercent = 0f;
			_weaponSkillBonus = 0f;
			_maxStaminaBonus = 0f;
			_staminaRegenPercent = 0f;
			_noiseReductionPercent = 0f;
			_maxHealthBonus = 0f;
			_frostResistance = 0f;
			_fireResistance = 0f;
			_poisonResistance = 0f;
			_fireDamage = 0f;
			_frostDamage = 0f;
			_lightningDamage = 0f;
			_poisonDamage = 0f;
			_spiritDamage = 0f;
			_critStrikePercent = 0f;
			_backstabBonusPercent = 0f;
			_knockbackPercent = 0f;
			_staminaOnKill = 0f;
			_staggerResistPercent = 0f;
			_moveSpeedPercent = 0f;
			_hpRegenPercent = 0f;
			_carryWeightBonus = 0f;
			_durabilityBonus = 0f;
			_eitrRegenPercent = 0f;
			_explorerPercent = 0f;
			_mythicLightningChance = 0f;
			_mythicFrostSlowPercent = 0f;
			_mythicHeimdallDamagePercent = 0f;
			_mythicUndyingPercent = 0f;
			_mythicBerserkerPercent = 0f;
			_mythicValhallaXpPercent = 0f;
			_toolMiningPercent = 0f;
			_toolChoppingPercent = 0f;
			_toolDamagePercent = 0f;
			_toolSwingSpeedPercent = 0f;
			_toolMasteryPercent = 0f;
			_toolEfficiencyPercent = 0f;
			_shieldFortressPercent = 0f;
			_shieldThorns = 0f;
			_shieldParryPercent = 0f;
			_shieldAegisPercent = 0f;
			_shieldResilienceStamina = 0f;
			_shieldBulwarkArmor = 0f;
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return;
			}
			foreach (ItemData equippedItem in inventory.GetEquippedItems())
			{
				if (EssenceLogic.IsEquipment(equippedItem) && ModifierData.HasAnyModifiers(equippedItem))
				{
					ProcessAffixes(ModifierData.GetAffixes(equippedItem));
					ProcessMythic(ModifierData.GetMythicAffix(equippedItem));
				}
			}
		}

		public static void Invalidate()
		{
			_lastEquipHash = -1;
		}

		private static int ComputeEquipHash(Player player)
		{
			int num = 17;
			Inventory inventory = ((Humanoid)player).GetInventory();
			if (inventory == null)
			{
				return num;
			}
			foreach (ItemData equippedItem in inventory.GetEquippedItems())
			{
				if (EssenceLogic.IsEquipment(equippedItem))
				{
					num = num * 31 + equippedItem.m_gridPos.x;
					num = num * 31 + equippedItem.m_gridPos.y;
					num = num * 31 + (equippedItem.m_shared?.m_name?.GetHashCode()).GetValueOrDefault();
					if (equippedItem.m_customData.TryGetValue("ror_affix_count", out var value))
					{
						num = num * 31 + value.GetHashCode();
					}
					if (equippedItem.m_customData.TryGetValue("ror_rarity", out var value2))
					{
						num = num * 31 + value2.GetHashCode();
					}
					if (equippedItem.m_customData.TryGetValue("ror_corrupted",