using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using AzuEPI;
using AzuEPI.Core.Slots;
using AzuExtendedPlayerInventory;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using ItemManager;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using PieceManager;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.ObjectPool;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
using YamlDotNet.Serialization.Callbacks;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: Guid("E74EB49A-461D-48EA-85BC-F462D60C98C4")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyProduct("Vikings_Magic")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("Vikings_Magic")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyFileVersion("1.1.9")]
[assembly: AssemblyCompany("Radamanto")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.9.0")]
[module: <57dc0856-7574-46de-a90f-0afdc9f60972>RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<c2a49c04-7492-4a52-8ba1-8f22eaaf5890>Embedded]
	internal sealed class <c2a49c04-7492-4a52-8ba1-8f22eaaf5890>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<c2a49c04-7492-4a52-8ba1-8f22eaaf5890>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <de71e391-1b70-422f-9c45-209544d5ed4d>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <de71e391-1b70-422f-9c45-209544d5ed4d>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <de71e391-1b70-422f-9c45-209544d5ed4d>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[<c2a49c04-7492-4a52-8ba1-8f22eaaf5890>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[<c2a49c04-7492-4a52-8ba1-8f22eaaf5890>Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class <57dc0856-7574-46de-a90f-0afdc9f60972>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <57dc0856-7574-46de-a90f-0afdc9f60972>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Vikings_Magic
{
	[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
	[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
	internal static class HealBookCleanse
	{
		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(0)]
		[HarmonyPatch(typeof(ZNetScene), "Awake")]
		private static class Patch_ZNetScene_Awake
		{
			private static void Postfix()
			{
				EnsureRpcRegistered();
			}
		}

		[HarmonyPatch(typeof(Aoe), "OnHit")]
		[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
		private static class Patch_Aoe_OnHit
		{
			private static void Postfix(Aoe __instance, Collider collider, Vector3 hitPoint, bool __result)
			{
				if (!__result)
				{
					return;
				}
				EnsureRpcRegistered();
				if (IsHealAoeInstance(__instance))
				{
					Player val = FindHitPlayer(collider);
					if (Object.op_Implicit((Object)(object)val))
					{
						CleansePlayerRouted(val);
					}
				}
			}

			[return: <de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(2)]
			private static Player FindHitPlayer(Collider collider)
			{
				GameObject val = Projectile.FindHitObject(collider);
				if (!Object.op_Implicit((Object)(object)val))
				{
					return null;
				}
				Player component = val.GetComponent<Player>();
				if (Object.op_Implicit((Object)(object)component))
				{
					return component;
				}
				return val.GetComponentInParent<Player>();
			}

			private static bool IsHealAoeInstance(Aoe aoe)
			{
				string name = ((Object)((Component)aoe).gameObject).name;
				for (int i = 0; i < HealAoEs.Length; i++)
				{
					string value = HealAoEs[i];
					if (name.StartsWith(value, StringComparison.Ordinal))
					{
						return true;
					}
				}
				return false;
			}
		}

		private const string RpcName = "VM_HealBookCleanse";

		[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(2)]
		private static ZRoutedRpc _registeredRpc;

		private static readonly string[] HealAoEs = new string[3] { "magic_heal_aoe_01", "magic_heal_aoe_02", "magic_heal_aoe_03" };

		private static void EnsureRpcRegistered()
		{
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (_registeredRpc != instance && instance != null)
			{
				instance.Register("VM_HealBookCleanse", (Action<long>)RPC_CleanseLocalPlayer);
				_registeredRpc = instance;
			}
		}

		private static void RPC_CleanseLocalPlayer(long sender)
		{
			Player localPlayer = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)localPlayer))
			{
				RemoveDebuffs(localPlayer);
			}
		}

		private static void CleansePlayerRouted(Player p)
		{
			if (((Character)p).IsOwner())
			{
				RemoveDebuffs(p);
				return;
			}
			ZNetView nview = ((Character)p).m_nview;
			if ((Object)(object)nview == (Object)null || !nview.IsValid())
			{
				return;
			}
			ZDO zDO = nview.GetZDO();
			if (zDO != null)
			{
				long owner = zDO.GetOwner();
				if (owner != 0 && ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(owner, "VM_HealBookCleanse", Array.Empty<object>());
				}
			}
		}

		private static void RemoveDebuffs(Player p)
		{
			SEMan sEMan = ((Character)p).GetSEMan();
			sEMan.RemoveStatusEffect(SEMan.s_statusEffectBurning, true);
			sEMan.RemoveStatusEffect(SEMan.s_statusEffectPoison, true);
			sEMan.RemoveStatusEffect(SEMan.s_statusEffectCold, true);
			sEMan.RemoveStatusEffect(SEMan.s_statusEffectFreezing, true);
			sEMan.RemoveStatusEffect(SEMan.s_statusEffectFrost, true);
		}
	}
	[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
	[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
	internal static class Registrations_BookStatusEffect
	{
		[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
		private sealed class BookCfg
		{
			public ConfigEntry<float> Ttl = null;

			public ConfigEntry<float> HealTotal = null;

			public ConfigEntry<float> Interval = null;
		}

		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(0)]
		[HarmonyPatch(typeof(ObjectDB), "Awake")]
		private static class Patch_ObjectDB_Awake
		{
			private static void Postfix()
			{
				ApplyAll();
			}
		}

		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(0)]
		[HarmonyPatch(typeof(ObjectDB), "CopyOtherDB")]
		private static class Patch_ObjectDB_CopyOtherDB
		{
			private static void Postfix()
			{
				ApplyAll();
			}
		}

		private static volatile bool _applyPending;

		private static readonly Dictionary<string, BookCfg> _cfgByBook = new Dictionary<string, BookCfg>();

		internal static void SetBookCfg(string prefab, ConfigEntry<float> ttl, ConfigEntry<float> healTotal, ConfigEntry<float> interval)
		{
			if (_cfgByBook.TryGetValue(prefab, out var value))
			{
				value.Ttl.SettingChanged -= OnConfigChanged;
				value.HealTotal.SettingChanged -= OnConfigChanged;
				value.Interval.SettingChanged -= OnConfigChanged;
			}
			_cfgByBook[prefab] = new BookCfg
			{
				Ttl = ttl,
				HealTotal = healTotal,
				Interval = interval
			};
			ttl.SettingChanged += OnConfigChanged;
			healTotal.SettingChanged += OnConfigChanged;
			interval.SettingChanged += OnConfigChanged;
			_applyPending = true;
		}

		private static void OnConfigChanged(object sender, EventArgs args)
		{
			_applyPending = true;
		}

		internal static void ApplyPending()
		{
			if (_applyPending && (Object)(object)ObjectDB.instance != (Object)null)
			{
				ApplyAll();
			}
		}

		private static void ApplyAll()
		{
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return;
			}
			_applyPending = false;
			foreach (KeyValuePair<string, BookCfg> item in _cfgByBook)
			{
				ApplyToBook(item.Key, item.Value);
			}
		}

		private static void ApplyToBook(string prefabName, BookCfg cfg)
		{
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(prefabName);
			if ((Object)(object)itemPrefab == (Object)null)
			{
				return;
			}
			ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			StatusEffect attackStatusEffect = component.m_itemData.m_shared.m_attackStatusEffect;
			if ((Object)(object)attackStatusEffect == (Object)null)
			{
				return;
			}
			float num = cfg.Ttl.Value;
			if (float.IsNaN(num) || float.IsInfinity(num))
			{
				num = 1f;
			}
			attackStatusEffect.m_ttl = Mathf.Max(0.1f, num);
			SE_Stats val = (SE_Stats)(object)((attackStatusEffect is SE_Stats) ? attackStatusEffect : null);
			if (val != null)
			{
				float num2 = cfg.HealTotal.Value;
				if (float.IsNaN(num2) || float.IsInfinity(num2))
				{
					num2 = 0f;
				}
				val.m_healthOverTime = Mathf.Max(0f, num2);
				val.m_healthOverTimeDuration = attackStatusEffect.m_ttl;
				float num3 = cfg.Interval.Value;
				if (float.IsNaN(num3) || float.IsInfinity(num3))
				{
					num3 = 1f;
				}
				num3 = Mathf.Clamp(num3, 0.1f, attackStatusEffect.m_ttl);
				int num4 = Mathf.Max(1, (int)Math.Min(2147483647.0, Math.Round((double)attackStatusEffect.m_ttl / (double)num3)));
				val.m_healthOverTimeInterval = attackStatusEffect.m_ttl / (float)num4;
			}
		}
	}
	[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
	[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
	internal static class AzuUtilityExclusivityCompat
	{
		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(0)]
		[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
		private static class Patch_Humanoid_UnequipItem_Guard
		{
			[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
			[HarmonyPriority(int.MaxValue)]
			private static bool Prefix(Humanoid __instance, ItemData item)
			{
				if (KeptItems.Count == 0 || !(__instance is Player) || item == null)
				{
					return true;
				}
				bool flag = CodexCustomSlotManager.IsCodexItem(item);
				bool flag2 = CodexCustomSlotManager.IsCodexItem(KeptItems.Peek());
				return !flag && !flag2;
			}
		}

		private const string ExclusivityTypeName = "AzuEPI.Game.Slots.UtilityExclusivity";

		private const string EnforceMethodName = "Enforce";

		[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(new byte[] { 1, 2 })]
		private static readonly Stack<ItemData> KeptItems = new Stack<ItemData>();

		internal static void Apply(Harmony harmony, ManualLogSource log)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_00b2: Expected O, but got Unknown
			Type type = AccessTools.TypeByName("AzuEPI.Game.Slots.UtilityExclusivity");
			if (type == null)
			{
				return;
			}
			List<MethodInfo> list = (from m in AccessTools.GetDeclaredMethods(type)
				where m.Name == "Enforce"
				select m).ToList();
			if (list.Count == 0)
			{
				log.LogWarning((object)"[AzuCompat] AzuEPI.Game.Slots.UtilityExclusivity.Enforce not found; codex items may compete with utility items.");
				return;
			}
			foreach (MethodInfo item in list)
			{
				harmony.Patch((MethodBase)item, new HarmonyMethod(typeof(AzuUtilityExclusivityCompat), "Enforce_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(AzuUtilityExclusivityCompat), "Enforce_Finalizer", (Type[])null), (HarmonyMethod)null);
			}
		}

		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(2)]
		private static void Enforce_Prefix(ItemData keep)
		{
			KeptItems.Push(keep);
		}

		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(2)]
		private static Exception Enforce_Finalizer(Exception __exception)
		{
			if (KeptItems.Count > 0)
			{
				KeptItems.Pop();
			}
			return __exception;
		}
	}
	[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
	[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
	internal static class MagicCooldowns
	{
		private static readonly Dictionary<string, SE_Stats> Templates = new Dictionary<string, SE_Stats>(StringComparer.Ordinal);

		internal static double GetNow()
		{
			return (double)DateTime.UtcNow.Ticks / 10000000.0;
		}

		internal static string SanitizeKey(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return string.Empty;
			}
			char[] array = s.ToCharArray();
			for (int i = 0; i < array.Length; i++)
			{
				bool flag;
				switch (array[i])
				{
				case '-':
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
				case 'A':
				case 'B':
				case 'C':
				case 'D':
				case 'E':
				case 'F':
				case 'G':
				case 'H':
				case 'I':
				case 'J':
				case 'K':
				case 'L':
				case 'M':
				case 'N':
				case 'O':
				case 'P':
				case 'Q':
				case 'R':
				case 'S':
				case 'T':
				case 'U':
				case 'V':
				case 'W':
				case 'X':
				case 'Y':
				case 'Z':
				case '_':
				case 'a':
				case 'b':
				case 'c':
				case 'd':
				case 'e':
				case 'f':
				case 'g':
				case 'h':
				case 'i':
				case 'j':
				case 'k':
				case 'l':
				case 'm':
				case 'n':
				case 'o':
				case 'p':
				case 'q':
				case 'r':
				case 's':
				case 't':
				case 'u':
				case 'v':
				case 'w':
				case 'x':
				case 'y':
				case 'z':
					flag = true;
					break;
				default:
					flag = false;
					break;
				}
				if (!flag)
				{
					array[i] = '_';
				}
			}
			return new string(array);
		}

		internal static bool IsOnCooldown(Player player, string id, string lastKey, string durationKey, string seName, out float remaining)
		{
			remaining = 0f;
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (string.IsNullOrEmpty(id))
			{
				return false;
			}
			if (string.IsNullOrEmpty(lastKey))
			{
				return false;
			}
			if (string.IsNullOrEmpty(durationKey))
			{
				return false;
			}
			if (player.m_customData == null || !player.m_customData.TryGetValue(lastKey, out var value))
			{
				return false;
			}
			if (!double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || double.IsNaN(result) || double.IsInfinity(result) || !player.m_customData.TryGetValue(durationKey, out var value2) || !float.TryParse(value2, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) || float.IsNaN(result2) || float.IsInfinity(result2) || result2 <= 0f)
			{
				ClearCooldown(player, id, lastKey, durationKey, seName);
				return false;
			}
			double now = GetNow();
			if (!player.m_customData.ContainsKey(lastKey + "_utc"))
			{
				if ((Object)(object)ZNet.instance == (Object)null)
				{
					return false;
				}
				double num = (double)ZNet.instance.GetTime().Ticks / 10000000.0;
				double val = num - result;
				result2 = (float)Math.Max(0.0, (double)result2 - Math.Max(0.0, val));
				RegisterUse(player, id, lastKey, durationKey, result2);
				result = now;
			}
			if (now < result)
			{
				result = now;
				player.m_customData[lastKey] = now.ToString(CultureInfo.InvariantCulture);
			}
			double num2 = now - result;
			if (num2 >= (double)result2)
			{
				ClearCooldown(player, id, lastKey, durationKey, seName);
				return false;
			}
			remaining = Mathf.Max(0f, (float)((double)result2 - num2));
			return remaining > 0f;
		}

		internal static void RegisterUse(Player player, string id, string lastKey, string durationKey, float duration)
		{
			if (!((Object)(object)player == (Object)null) && !string.IsNullOrEmpty(id) && !string.IsNullOrEmpty(lastKey) && !string.IsNullOrEmpty(durationKey) && player.m_customData != null)
			{
				double now = GetNow();
				if (float.IsNaN(duration) || float.IsInfinity(duration))
				{
					duration = 0f;
				}
				duration = Mathf.Max(0f, duration);
				player.m_customData[lastKey + "_utc"] = "1";
				player.m_customData[lastKey] = now.ToString(CultureInfo.InvariantCulture);
				player.m_customData[durationKey] = duration.ToString(CultureInfo.InvariantCulture);
			}
		}

		internal static void ClearCooldown(Player player, string id, string lastKey, string durationKey, string seName)
		{
			if (!((Object)(object)player == (Object)null))
			{
				if (player.m_customData != null)
				{
					player.m_customData.Remove(lastKey);
					player.m_customData.Remove(durationKey);
					player.m_customData.Remove(lastKey + "_utc");
				}
				RemoveStatusEffect(player, seName);
			}
		}

		internal static void RemoveStatusEffect(Player player, string seName)
		{
			if ((Object)(object)player == (Object)null || string.IsNullOrEmpty(seName))
			{
				return;
			}
			try
			{
				SEMan sEMan = ((Character)player).GetSEMan();
				int stableHashCode = StringExtensionMethods.GetStableHashCode(seName);
				if (sEMan != null && (Object)(object)sEMan.GetStatusEffect(stableHashCode) != (Object)null)
				{
					sEMan.RemoveStatusEffect(stableHashCode, true);
				}
			}
			catch
			{
			}
		}

		internal static void ApplyStatusEffect(Player player, string seName, string tokenName, [<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(2)] Sprite icon, float duration, bool ceilDuration = false)
		{
			if ((Object)(object)player == (Object)null || string.IsNullOrEmpty(seName) || string.IsNullOrEmpty(tokenName))
			{
				return;
			}
			duration = Mathf.Max(0f, duration);
			if (ceilDuration)
			{
				duration = Mathf.Ceil(duration);
			}
			if (duration <= 0f)
			{
				return;
			}
			SEMan sEMan = ((Character)player).GetSEMan();
			if (sEMan == null || float.IsNaN(duration) || float.IsInfinity(duration))
			{
				return;
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(seName);
			StatusEffect statusEffect = sEMan.GetStatusEffect(stableHashCode);
			if ((Object)(object)statusEffect != (Object)null)
			{
				statusEffect.m_ttl = duration;
				statusEffect.m_icon = icon;
				statusEffect.ResetTime();
				return;
			}
			if (!Templates.TryGetValue(seName, out var value) || (Object)(object)value == (Object)null)
			{
				value = ScriptableObject.CreateInstance<SE_Stats>();
				((Object)value).name = seName;
				Templates[seName] = value;
			}
			((StatusEffect)value).m_name = tokenName;
			((StatusEffect)value).m_icon = icon;
			((StatusEffect)value).m_ttl = duration;
			sEMan.AddStatusEffect((StatusEffect)(object)value, true, 0, 0f, (short)(-1));
		}

		internal static void DisposeTemplates()
		{
			foreach (SE_Stats value in Templates.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			Templates.Clear();
		}
	}
	[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
	[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
	internal static class SetEquipCooldown
	{
		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(0)]
		[HarmonyPatch(typeof(Humanoid), "EquipItem")]
		internal static class Patch_EquipItem
		{
			[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
			private static bool Prefix(ref bool __result, Humanoid __instance, ItemData item, bool triggerEquipEffects)
			{
				try
				{
					if ((Object)(object)__instance == (Object)null || !((Character)__instance).IsPlayer())
					{
						return true;
					}
					if (!CE_Enable.Value)
					{
						return true;
					}
					if (!TryGetGroupFromItem(item, out var groupId))
					{
						return true;
					}
					Player val = (Player)(object)((__instance is Player) ? __instance : null);
					if ((Object)(object)val == (Object)null)
					{
						return true;
					}
					if (IsOnCooldown(val, groupId, out var remaining) && remaining > 0.1f)
					{
						__result = false;
						ApplyCooldownStatusEffect(val, groupId, remaining);
						return false;
					}
					return true;
				}
				catch
				{
					return true;
				}
			}
		}

		[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
		[HarmonyPatch(typeof(Humanoid), "UnequipItem")]
		internal static class Patch_UnequipItem
		{
			private static void Prefix(Humanoid __instance, ItemData item, bool triggerEquipEffects, ref bool __state)
			{
				__state = false;
				try
				{
					if (!((Object)(object)__instance == (Object)null) && ((Character)__instance).IsPlayer() && CE_Enable.Value && TryGetGroupFromItem(item, out var _) && __instance.IsItemEquiped(item) && HasHealerSetEffect(__instance))
					{
						__state = true;
					}
				}
				catch
				{
					__state = false;
				}
			}

			private static void Postfix(Humanoid __instance, ItemData item, bool triggerEquipEffects, bool __state)
			{
				try
				{
					if (!__state || (Object)(object)__instance == (Object)null || !((Character)__instance).IsPlayer() || !CE_Enable.Value || !TryGetGroupFromItem(item, out var groupId) || __instance.IsItemEquiped(item))
					{
						return;
					}
					Player val = (Player)(object)((__instance is Player) ? __instance : null);
					if (!((Object)(object)val == (Object)null))
					{
						float num = Mathf.Max(0f, CE_Seconds.Value);
						if (!(num <= 0f))
						{
							RegisterRemoval(val, groupId, num);
							ApplyCooldownStatusEffect(val, groupId, num);
						}
					}
				}
				catch
				{
				}
			}
		}

		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(0)]
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		internal static class Patch_Player_OnSpawned
		{
			[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
			private static void Postfix(Player __instance)
			{
				try
				{
					if (!((Object)(object)__instance == (Object)null) && CE_Enable.Value && IsOnCooldown(__instance, "global", out var remaining) && remaining > 0.1f)
					{
						ApplyCooldownStatusEffect(__instance, "global", remaining);
					}
				}
				catch
				{
				}
			}
		}

		private static readonly HashSet<string> Pieces = new HashSet<string>(StringComparer.Ordinal)
		{
			"RDM_bforest_healer_helmet", "RDM_bforest_healer_chest", "RDM_bforest_healer_legs", "RDM_bforest_healer_cape", "RDM_mountain_healer_helmet", "RDM_mountain_healer_chest", "RDM_mountain_healer_legs", "RDM_mountain_healer_cape", "RDM_mistlands_healer_helmet", "RDM_mistlands_healer_chest",
			"RDM_mistlands_healer_legs", "RDM_mistlands_healer_cape"
		};

		private static readonly int[] HealerSetEffectHashes = new int[3]
		{
			StringExtensionMethods.GetStableHashCode("SetEffect_healer_bforest"),
			StringExtensionMethods.GetStableHashCode("SetEffect_healer_mountain"),
			StringExtensionMethods.GetStableHashCode("SetEffect_healer_mistlands")
		};

		private const string CooldownId = "healer_armor_equip_global";

		private const string GroupId = "global";

		private const string CustomKeyPrefix = "vmagic_cd_healer_armor_equip_";

		private const string SePrefix = "SE_VMAGIC_CD_HEALER_ARMOR_EQUIP_";

		private const string SeToken = "$se_equip_healer";

		private const string CooldownIconSpriteName = "armor_cooldown_icon";

		[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(2)]
		private static Sprite _cooldownIcon;

		internal static ConfigEntry<bool> CE_Enable = null;

		internal static ConfigEntry<float> CE_Seconds = null;

		private static void EnsureIcon()
		{
			if (!((Object)(object)_cooldownIcon != (Object)null))
			{
				_cooldownIcon = Magic_AssetLoader.GetSprite("armor_cooldown_icon");
			}
		}

		private static string LastKey(string groupId)
		{
			return "vmagic_cd_healer_armor_equip_" + MagicCooldowns.SanitizeKey(groupId) + "_last";
		}

		private static string DurationKey(string groupId)
		{
			return "vmagic_cd_healer_armor_equip_" + MagicCooldowns.SanitizeKey(groupId) + "_duration";
		}

		private static string SeName(string groupId)
		{
			return "SE_VMAGIC_CD_HEALER_ARMOR_EQUIP_" + MagicCooldowns.SanitizeKey(groupId).ToUpperInvariant();
		}

		private static bool TryGetGroupFromItem(ItemData item, out string groupId)
		{
			groupId = string.Empty;
			if ((Object)(object)item?.m_dropPrefab == (Object)null)
			{
				return false;
			}
			string text = Utils.GetPrefabName(item.m_dropPrefab) ?? string.Empty;
			if (text.Length == 0)
			{
				return false;
			}
			if (!Pieces.Contains(text))
			{
				return false;
			}
			groupId = "global";
			return true;
		}

		private static bool HasHealerSetEffect(Humanoid humanoid)
		{
			if ((Object)(object)humanoid == (Object)null)
			{
				return false;
			}
			try
			{
				SEMan sEMan = ((Character)humanoid).GetSEMan();
				if (sEMan == null)
				{
					return false;
				}
				for (int i = 0; i < HealerSetEffectHashes.Length; i++)
				{
					if ((Object)(object)sEMan.GetStatusEffect(HealerSetEffectHashes[i]) != (Object)null)
					{
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool IsOnCooldown(Player player, string groupId, out float remaining)
		{
			remaining = 0f;
			if (string.IsNullOrEmpty(groupId))
			{
				return false;
			}
			return MagicCooldowns.IsOnCooldown(player, "healer_armor_equip_global", LastKey(groupId), DurationKey(groupId), SeName(groupId), out remaining);
		}

		private static void RegisterRemoval(Player player, string groupId, float duration)
		{
			if (!string.IsNullOrEmpty(groupId))
			{
				MagicCooldowns.RegisterUse(player, "healer_armor_equip_global", LastKey(groupId), DurationKey(groupId), duration);
			}
		}

		private static void ApplyCooldownStatusEffect(Player player, string groupId, float duration)
		{
			if (!string.IsNullOrEmpty(groupId))
			{
				EnsureIcon();
				MagicCooldowns.ApplyStatusEffect(player, SeName(groupId), "$se_equip_healer", _cooldownIcon, duration, ceilDuration: true);
			}
		}
	}
	internal static class HealerArmorEquipCooldownTooltip
	{
		private static bool _handlerRegistered;

		private static bool _placeholdersRegistered;

		[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(1)]
		private static readonly string[] DescriptionTokens = new string[12]
		{
			"item_RDM_bforest_healer_helmet_description", "item_RDM_bforest_healer_chest_description", "item_RDM_bforest_healer_legs_description", "item_RDM_bforest_healer_cape_description", "item_RDM_mountain_healer_helmet_description", "item_RDM_mountain_healer_chest_description", "item_RDM_mountain_healer_legs_description", "item_RDM_mountain_healer_cape_description", "item_RDM_mistlands_healer_helmet_description", "item_RDM_mistlands_healer_chest_description",
			"item_RDM_mistlands_healer_legs_description", "item_RDM_mistlands_healer_cape_description"
		};

		internal static void Register()
		{
			if (!_handlerRegistered)
			{
				_handlerRegistered = true;
				Localizer.OnLocalizationComplete += Setup;
			}
		}

		private static void Setup()
		{
			if (_placeholdersRegistered)
			{
				return;
			}
			_placeholdersRegistered = true;
			for (int i = 0; i < DescriptionTokens.Length; i++)
			{
				Localizer.AddPlaceholder(DescriptionTokens[i], "cooldown", SetEquipCooldown.CE_Seconds, [<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)] (float value) => value.ToString("0.#"));
			}
		}
	}
	[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
	[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
	internal static class WeaponPrimaryGlobalCooldown
	{
		[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
		internal sealed class Cfg
		{
			public ConfigEntry<bool> Enable = null;

			public ConfigEntry<float> CooldownSeconds = null;

			public ConfigEntry<float> HealerSetCooldownMultiplier = null;
		}

		[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
		[HarmonyPatch(typeof(Humanoid), "StartAttack", new Type[]
		{
			typeof(Character),
			typeof(bool)
		})]
		internal static class Patch_Humanoid_StartAttack_GlobalPrimary
		{
			private static bool Prefix(Humanoid __instance, Character target, bool secondaryAttack)
			{
				if (secondaryAttack)
				{
					return true;
				}
				if ((Object)(object)__instance == (Object)null || !((Character)__instance).IsPlayer())
				{
					return true;
				}
				if (!_cfg.Enable.Value)
				{
					return true;
				}
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				ItemData currentWeapon = __instance.GetCurrentWeapon();
				if (currentWeapon == null)
				{
					return true;
				}
				if (!IsTrackedWeapon(currentWeapon))
				{
					return true;
				}
				float effectiveCooldownSeconds = GetEffectiveCooldownSeconds(val);
				if (effectiveCooldownSeconds <= 0f)
				{
					return true;
				}
				if (IsOnCooldown(val, out var remaining) && remaining > 0.1f)
				{
					return false;
				}
				return true;
			}

			private static void Postfix(Humanoid __instance, Character target, bool secondaryAttack, bool __result)
			{
				if (!__result || secondaryAttack || (Object)(object)__instance == (Object)null || !((Character)__instance).IsPlayer() || !_cfg.Enable.Value)
				{
					return;
				}
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				ItemData currentWeapon = __instance.GetCurrentWeapon();
				if (currentWeapon != null && IsTrackedWeapon(currentWeapon))
				{
					float effectiveCooldownSeconds = GetEffectiveCooldownSeconds(val);
					if (!(effectiveCooldownSeconds <= 0f))
					{
						RegisterUse(val, effectiveCooldownSeconds);
						EnsureCooldownIcon();
						Sprite icon = _cooldownIcon ?? GetAnyBookFallbackIcon();
						ApplyCooldownStatusEffect(val, icon, effectiveCooldownSeconds);
					}
				}
			}
		}

		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(0)]
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		internal static class Patch_Player_OnSpawned_GlobalPrimary
		{
			[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
			private static void Postfix(Player __instance)
			{
				if ((Object)(object)__instance == (Object)null || !_cfg.Enable.Value)
				{
					return;
				}
				float effectiveCooldownSeconds = GetEffectiveCooldownSeconds(__instance);
				if (!(effectiveCooldownSeconds <= 0f) && IsOnCooldown(__instance, out var remaining))
				{
					SEMan sEMan = ((Character)__instance).GetSEMan();
					if (sEMan != null && !((Object)(object)sEMan.GetStatusEffect(StringExtensionMethods.GetStableHashCode("SE_VMAGIC_CD_HEALING_BOOKS")) != (Object)null))
					{
						EnsureCooldownIcon();
						Sprite icon = _cooldownIcon ?? GetAnyBookFallbackIcon();
						ApplyCooldownStatusEffect(__instance, icon, remaining);
					}
				}
			}
		}

		private static readonly string[] BookPrefabs = new string[3] { "RDM_book_heal_01", "RDM_book_heal_02", "RDM_book_heal_03" };

		private static readonly HashSet<string> BookPrefabSet = new HashSet<string>(BookPrefabs, StringComparer.Ordinal);

		private static readonly int[] ReduceCooldownSeHashes = new int[3]
		{
			StringExtensionMethods.GetStableHashCode("SetEffect_healer_bforest"),
			StringExtensionMethods.GetStableHashCode("SetEffect_healer_mountain"),
			StringExtensionMethods.GetStableHashCode("SetEffect_healer_mistlands")
		};

		private const string CooldownId = "healing_books";

		private const string CustomDataKeyLast = "vmagic_cd_healing_books_last";

		private const string CustomDataKeyDuration = "vmagic_cd_healing_books_duration";

		private const string SeName = "SE_VMAGIC_CD_HEALING_BOOKS";

		private const string SeToken = "$se_cooldown_healing_book";

		private const string CooldownIconSpriteName = "cooldown_icon";

		[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(2)]
		private static Sprite _cooldownIcon;

		internal static readonly Cfg _cfg = new Cfg();

		private static bool IsTrackedWeapon(ItemData weapon)
		{
			if ((Object)(object)weapon?.m_dropPrefab == (Object)null)
			{
				return false;
			}
			return BookPrefabSet.Contains(Utils.GetPrefabName(weapon.m_dropPrefab));
		}

		private static float GetEffectiveCooldownSeconds(Player player)
		{
			float num = Mathf.Max(0f, _cfg.CooldownSeconds.Value);
			if (num <= 0f)
			{
				return 0f;
			}
			if ((Object)(object)player == (Object)null)
			{
				return num;
			}
			try
			{
				SEMan sEMan = ((Character)player).GetSEMan();
				if (sEMan == null)
				{
					return num;
				}
				for (int i = 0; i < ReduceCooldownSeHashes.Length; i++)
				{
					if (!((Object)(object)sEMan.GetStatusEffect(ReduceCooldownSeHashes[i]) == (Object)null))
					{
						num *= Mathf.Max(0f, _cfg.HealerSetCooldownMultiplier.Value);
						break;
					}
				}
			}
			catch
			{
			}
			return num;
		}

		private static void EnsureCooldownIcon()
		{
			if (!((Object)(object)_cooldownIcon != (Object)null))
			{
				_cooldownIcon = Magic_AssetLoader.GetSprite("cooldown_icon");
			}
		}

		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(2)]
		private static Sprite GetAnyBookFallbackIcon()
		{
			try
			{
				if ((Object)(object)ObjectDB.instance == (Object)null)
				{
					return null;
				}
				for (int i = 0; i < BookPrefabs.Length; i++)
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(BookPrefabs[i]);
					if (!((Object)(object)itemPrefab == (Object)null))
					{
						ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
						if (component?.m_itemData?.m_shared?.m_icons != null && component.m_itemData.m_shared.m_icons.Length != 0)
						{
							return component.m_itemData.m_shared.m_icons[0];
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static bool IsOnCooldown(Player player, out float remaining)
		{
			return MagicCooldowns.IsOnCooldown(player, "healing_books", "vmagic_cd_healing_books_last", "vmagic_cd_healing_books_duration", "SE_VMAGIC_CD_HEALING_BOOKS", out remaining);
		}

		private static void RegisterUse(Player player, float duration)
		{
			MagicCooldowns.RegisterUse(player, "healing_books", "vmagic_cd_healing_books_last", "vmagic_cd_healing_books_duration", duration);
		}

		private static void ApplyCooldownStatusEffect(Player player, [<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(2)] Sprite icon, float duration)
		{
			MagicCooldowns.ApplyStatusEffect(player, "SE_VMAGIC_CD_HEALING_BOOKS", "$se_cooldown_healing_book", icon, duration);
		}
	}
	[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
	[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
	internal static class WeaponSecondaryCooldown
	{
		[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
		[HarmonyPatch(typeof(Humanoid), "StartAttack", new Type[]
		{
			typeof(Character),
			typeof(bool)
		})]
		internal static class Patch_Humanoid_StartAttack
		{
			private static bool Prefix(Humanoid __instance, Character target, bool secondaryAttack)
			{
				if (!secondaryAttack)
				{
					return true;
				}
				if ((Object)(object)__instance == (Object)null || !((Character)__instance).IsPlayer())
				{
					return true;
				}
				if (!CE_Enable.Value)
				{
					return true;
				}
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				ItemData currentWeapon = __instance.GetCurrentWeapon();
				if (currentWeapon == null)
				{
					return true;
				}
				if (!IsListedStaff(currentWeapon))
				{
					return true;
				}
				float num = Mathf.Max(0f, CE_Seconds.Value);
				if (num <= 0f)
				{
					return true;
				}
				if (IsOnCooldown(val, out var remaining) && remaining > 0.1f)
				{
					return false;
				}
				return true;
			}

			private static void Postfix(Humanoid __instance, Character target, bool secondaryAttack, bool __result)
			{
				if (!__result || !secondaryAttack || (Object)(object)__instance == (Object)null || !((Character)__instance).IsPlayer() || !CE_Enable.Value)
				{
					return;
				}
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				ItemData currentWeapon = __instance.GetCurrentWeapon();
				if (currentWeapon == null || !IsListedStaff(currentWeapon))
				{
					return;
				}
				float num = Mathf.Max(0f, CE_Seconds.Value);
				if (num <= 0f)
				{
					return;
				}
				RegisterUse(val, num);
				EnsureCooldownIcon();
				Sprite val2 = _cooldownIcon;
				if ((Object)(object)val2 == (Object)null)
				{
					try
					{
						if (currentWeapon.m_shared?.m_icons != null && currentWeapon.m_shared.m_icons.Length != 0)
						{
							val2 = currentWeapon.m_shared.m_icons[0];
						}
					}
					catch
					{
					}
				}
				ApplyCooldownStatusEffect(val, val2, num);
			}
		}

		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(0)]
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		internal static class Patch_Player_OnSpawned
		{
			[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
			private static void Postfix(Player __instance)
			{
				if (!((Object)(object)__instance == (Object)null) && CE_Enable.Value && IsOnCooldown(__instance, out var remaining))
				{
					SEMan sEMan = ((Character)__instance).GetSEMan();
					if (sEMan != null && !((Object)(object)sEMan.GetStatusEffect(StringExtensionMethods.GetStableHashCode("SE_VMAGIC_CD_STAFF_SECONDARY")) != (Object)null))
					{
						EnsureCooldownIcon();
						Sprite cooldownIcon = _cooldownIcon;
						ApplyCooldownStatusEffect(__instance, cooldownIcon, remaining);
					}
				}
			}
		}

		private static readonly HashSet<string> StaffPrefabs = new HashSet<string>(StringComparer.Ordinal) { "RDM_staff_meadows", "RDM_staff_bforest", "RDM_staff_swamp", "RDM_staff_mountain", "RDM_staff_plains", "RDM_staff_mistlands", "RDM_staff_ashlands" };

		private const string CooldownId = "staff_secondary";

		private const string CustomDataKeyLast = "vmagic_cd_staff_secondary_last";

		private const string CustomDataKeyDuration = "vmagic_cd_staff_secondary_duration";

		private const string SeName = "SE_VMAGIC_CD_STAFF_SECONDARY";

		private const string SeToken = "$se_cooldown_global_staff";

		private const string CooldownIconSpriteName = "staff_cooldown_icon";

		[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(2)]
		private static Sprite _cooldownIcon;

		internal static ConfigEntry<bool> CE_Enable = null;

		internal static ConfigEntry<float> CE_Seconds = null;

		private static bool IsListedStaff(ItemData weapon)
		{
			if ((Object)(object)weapon?.m_dropPrefab == (Object)null)
			{
				return false;
			}
			string item = Utils.GetPrefabName(weapon.m_dropPrefab) ?? string.Empty;
			return StaffPrefabs.Contains(item);
		}

		private static void EnsureCooldownIcon()
		{
			if (!((Object)(object)_cooldownIcon != (Object)null))
			{
				_cooldownIcon = Magic_AssetLoader.GetSprite("staff_cooldown_icon");
			}
		}

		private static bool IsOnCooldown(Player player, out float remaining)
		{
			return MagicCooldowns.IsOnCooldown(player, "staff_secondary", "vmagic_cd_staff_secondary_last", "vmagic_cd_staff_secondary_duration", "SE_VMAGIC_CD_STAFF_SECONDARY", out remaining);
		}

		private static void RegisterUse(Player player, float duration)
		{
			MagicCooldowns.RegisterUse(player, "staff_secondary", "vmagic_cd_staff_secondary_last", "vmagic_cd_staff_secondary_duration", duration);
		}

		private static void ApplyCooldownStatusEffect(Player player, [<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(2)] Sprite icon, float duration)
		{
			MagicCooldowns.ApplyStatusEffect(player, "SE_VMAGIC_CD_STAFF_SECONDARY", "$se_cooldown_global_staff", icon, duration);
		}
	}
	[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
	[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
	internal static class StaffSecondaryDamageModifiers
	{
		[HarmonyPatch(typeof(Aoe), "Setup")]
		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(0)]
		private static class Patch_Aoe_Setup
		{
			[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
			private static void Postfix(Aoe __instance, Character owner, HitData hitData, ItemData item)
			{
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					if (!((Object)(object)owner == (Object)null) && owner.IsPlayer() && (hitData == null || !__instance.m_useAttackSettings) && IsSecondaryPrefab(((Component)__instance).gameObject))
					{
						__instance.m_damage = ApplyOwnerModifiers(owner, item, __instance.m_damage);
					}
				}
				catch
				{
				}
			}
		}

		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(0)]
		[HarmonyPatch(typeof(Projectile), "Setup")]
		private static class Patch_Projectile_Setup
		{
			[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
			private static void Postfix(Projectile __instance, Character owner, HitData hitData, ItemData item)
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					if (!((Object)(object)owner == (Object)null) && owner.IsPlayer() && hitData == null && IsSecondaryPrefab(((Component)__instance).gameObject))
					{
						__instance.m_damage = ApplyOwnerModifiers(owner, item, __instance.m_damage);
					}
				}
				catch
				{
				}
			}
		}

		private static readonly HashSet<string> SecondaryPrefabs = new HashSet<string>(StringComparer.Ordinal) { "projectile_nova_aoe_meadows", "projectile_nova_aoe_bforest", "projectile_nova_aoe_swamp", "projectile_nova_aoe_mountain", "projectile_meteor_plains", "projectile_nova_aoe_mistlands", "projectile_nova_aoe_ashlands" };

		private static bool IsSecondaryPrefab(GameObject go)
		{
			return (Object)(object)go != (Object)null && SecondaryPrefabs.Contains(Utils.GetPrefabName(go));
		}

		private static SkillType ResolveSkill(Character owner, [<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(2)] ItemData item)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			object obj = item;
			if (obj == null)
			{
				Character obj2 = ((owner is Humanoid) ? owner : null);
				obj = ((obj2 != null) ? ((Humanoid)obj2).GetCurrentWeapon() : null);
			}
			ItemData val = (ItemData)obj;
			return (SkillType)((val?.m_shared == null) ? 9 : ((int)val.m_shared.m_skillType));
		}

		private static DamageTypes ApplyOwnerModifiers(Character owner, [<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(2)] ItemData item, DamageTypes damage)
		{
			//IL_0014: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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)
			SEMan sEMan = owner.GetSEMan();
			if (sEMan == null)
			{
				return damage;
			}
			HitData val = new HitData
			{
				m_damage = damage
			};
			sEMan.ModifyAttack(ResolveSkill(owner, item), ref val);
			return val.m_damage;
		}
	}
	[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
	[<de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(0)]
	internal static class WaterBottle_UseItemVanilla
	{
		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(0)]
		[HarmonyPatch(typeof(Humanoid))]
		private static class Humanoid_UseItem_Patch
		{
			[HarmonyPatch("UseItem")]
			[HarmonyPatch(new Type[]
			{
				typeof(Inventory),
				typeof(ItemData),
				typeof(bool)
			})]
			[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(1)]
			private static bool Prefix(Humanoid __instance, Inventory inventory, ItemData item, bool fromInventoryGui)
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				if ((Object)(object)Player.m_localPlayer != (Object)(object)val)
				{
					return true;
				}
				if (!IsEmptyBottle(item))
				{
					return true;
				}
				Vector3 position = ((Component)val).transform.position;
				if (!IsAllowedBiome(position))
				{
					return true;
				}
				if (!IsPlayerInWaterByLevel(val))
				{
					return true;
				}
				if (TryReplaceStackInSameSlot(val, inventory ?? ((Humanoid)val).GetInventory(), item))
				{
					return false;
				}
				return true;
			}
		}

		private const string EmptyPrefabName = "RDM_water_bootle_empty";

		private const string FullPrefabName = "RDM_water_bootle_full";

		private const string FillSfxPrefabName = "sfx_water_bottle_rd_magic";

		private const float WaterEpsilon = 0.1f;

		private const float GroundEpsilon = 0.15f;

		private static readonly Biome AllowedBiomes = (Biome)25;

		private static float _nextAllowedTime;

		[<f62f5b79-c7b4-4b95-9281-10002dddc28e>NullableContext(2)]
		private static bool IsEmptyBottle(ItemData item)
		{
			if (item == null)
			{
				return false;
			}
			if ((Object)(object)item.m_dropPrefab != (Object)null && ((Object)item.m_dropPrefab).name == "RDM_water_bootle_empty")
			{
				return true;
			}
			string text = ((item.m_shared != null) ? item.m_shared.m_name : null);
			if (!string.IsNullOrEmpty(text))
			{
				switch (text)
				{
				case "$item_RDM_water_bootle_empty":
					return true;
				case "$RDM_water_bootle_empty":
					return true;
				case "RDM_water_bootle_empty":
					return true;
				}
			}
			return false;
		}

		private static bool IsAllowedBiome(Vector3 pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			Biome val = Heightmap.FindBiome(pos);
			return (val & AllowedBiomes) > 0;
		}

		private static bool IsPlayerInWaterByLevel(Player player)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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)
			ZoneSystem instance = ZoneSystem.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			float waterLevel = instance.m_waterLevel;
			Vector3 position = ((Component)player).transform.position;
			if (position.y > waterLevel + 0.1f)
			{
				return false;
			}
			float groundHeight = instance.GetGroundHeight(position);
			if (groundHeight > waterLevel - 0.15f)
			{
				return false;
			}
			return true;
		}

		private static void PlayFillSfx(Vector3 pos)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ZNetScene.instance == (Object)null))
			{
				GameObject prefab = ZNetScene.instance.GetPrefab("sfx_water_bottle_rd_magic");
				if (!((Object)(object)prefab == (Object)null))
				{
					Object.Instantiate<GameObject>(prefab, pos, Quaternion.identity);
				}
			}
		}

		[return: <de71e391-1b70-422f-9c45-209544d5ed4d>Nullable(2)]
		private static ItemData CreateFullItemData(int stack, ItemData sourceItem)
		{
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return null;
			}
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab("RDM_water_bootle_full");
			if ((Object)(object)itemPrefab == (Object)null)
			{
				return null;
			}
			ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			ItemData val = sourceItem.Clone();
			val.m_shared = component.m_itemData.m_shared;
			val.m_dropPrefab = itemPrefab;
			val.m_stack = stack;
			val.m_equipped = false;
			val.m_durability = Mathf.Min(val.GetMaxDurability(), sourceItem.m_durability);
			return val;
		}

		private static int GetFullMaxStack()
		{
			GameObject val = (((Object)(object)ObjectDB.instance != (Object)null) ? ObjectDB.instance.GetItemPrefab("RDM_water_bootle_full") : null);
			ItemDrop val2 = (((Object)(object)val != (Object)null) ? val.GetComponent<ItemDrop>() : null);
			return ((Object)(object)val2 != (Object)null) ? Mathf.Max(1, val2.m_itemData.m_shared.m_maxStackSize) : int.MaxValue;
		}

		private static bool TryReplaceStackInSameSlot(Player player, Inventory inventory, ItemData emptyItem)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			if (Time.time < _nextAllowedTime || inventory == null || !inventory.ContainsItem(emptyItem))
			{
				return false;
			}
			int fullMaxStack = GetFullMaxStack();
			if (emptyItem.m_stack > fullMaxStack)
			{
				return TryFillPartialStack(player, inventory, emptyItem, fullMaxStack);
			}
			ItemData val = CreateFullItemData(emptyItem.m_stack, emptyItem);
			if (val == null || val.m_stack <= 0)
			{
				return false;
			}
			List<ItemData> allItems = inventory.GetAllItems();
			int num = allItems.IndexOf(emptyItem);
			if (num < 0)
			{
				return false;
			}
			allItems[num] = val;
			inventory.Changed(false, false);
			_nextAllowedTime = Time.time + 0.25f;
			PlayFillSfx(((Component)player).transform.position);
			return true;
		}

		private static bool TryFillPartialStack(Player player, Inventory inventory, ItemData emptyItem, int amount)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			ItemData val = CreateFullItemData(amount, emptyItem);
			if (val == null || !inventory.CanAddItem(val, amount))
			{
				return false;
			}
			emptyItem.m_stack -= amount;
			if (!inventory.AddItem(val))
			{
				emptyItem.m_stack += amount;
				inventory.Changed(false, false);
				return false;
			}
			_nextAllowedTime = Time.time + 0.25f;
			PlayFillSfx(((Component)player).transform.position);
			return true;
		}
	}
	internal static class Registrations_Armor
	{
		public static void RegisterArmor()
		{
			Item item = new Item("rd_magic", "RDM_meadows_hat");
			item.Crafting.Add("RDM_mage_table_01", 1);
			item.RequiredItems.Add("DeerHide", 4);
			item.RequiredItems.Add("LeatherScraps", 4);
			item.RequiredUpgradeItems.Add("DeerHide", 2);
			item.RequiredUpgradeItems.Add("LeatherScraps", 2);
			item.RequiredUpgradeItems.Add("BoneFragments", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item2 = new Item("rd_magic", "RDM_meadows_chest");
			item2.Crafting.Add("RDM_mage_table_01", 1);
			item2.RequiredItems.Add("DeerHide", 10);
			item2.RequiredItems.Add("LeatherScraps", 10);
			item2.RequiredUpgradeItems.Add("DeerHide", 2);
			item2.RequiredUpgradeItems.Add("LeatherScraps", 2);
			item2.RequiredUpgradeItems.Add("BoneFragments", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item2.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item3 = new Item("rd_magic", "RDM_meadows_legs");
			item3.Crafting.Add("RDM_mage_table_01", 1);
			item3.RequiredItems.Add("DeerHide", 8);
			item3.RequiredItems.Add("LeatherScraps", 8);
			item3.RequiredUpgradeItems.Add("DeerHide", 2);
			item3.RequiredUpgradeItems.Add("LeatherScraps", 2);
			item3.RequiredUpgradeItems.Add("BoneFragments", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item3.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item4 = new Item("rd_magic", "RDM_meadows_cape");
			item4.Crafting.Add("RDM_mage_table_01", 1);
			item4.RequiredItems.Add("DeerHide", 6);
			item4.RequiredItems.Add("LeatherScraps", 6);
			item4.RequiredUpgradeItems.Add("DeerHide", 2);
			item4.RequiredUpgradeItems.Add("LeatherScraps", 2);
			item4.RequiredUpgradeItems.Add("BoneFragments", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item4.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item5 = new Item("rd_magic", "RDM_bforest_hat");
			item5.Crafting.Add("RDM_mage_table_01", 1);
			item5.RequiredItems.Add("TrollHide", 4);
			item5.RequiredItems.Add("BoneFragments", 6);
			item5.RequiredItems.Add("Bronze", 5);
			item5.RequiredUpgradeItems.Add("TrollHide", 1);
			item5.RequiredUpgradeItems.Add("BoneFragments", 2);
			item5.RequiredUpgradeItems.Add("Bronze", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item5.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item6 = new Item("rd_magic", "RDM_bforest_chest");
			item6.Crafting.Add("RDM_mage_table_01", 1);
			item6.RequiredItems.Add("TrollHide", 4);
			item6.RequiredItems.Add("BoneFragments", 8);
			item6.RequiredItems.Add("Bronze", 5);
			item6.RequiredUpgradeItems.Add("TrollHide", 1);
			item6.RequiredUpgradeItems.Add("BoneFragments", 3);
			item6.RequiredUpgradeItems.Add("Bronze", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item6.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item7 = new Item("rd_magic", "RDM_bforest_legs");
			item7.Crafting.Add("RDM_mage_table_01", 1);
			item7.RequiredItems.Add("TrollHide", 4);
			item7.RequiredItems.Add("BoneFragments", 6);
			item7.RequiredItems.Add("Bronze", 5);
			item7.RequiredUpgradeItems.Add("TrollHide", 1);
			item7.RequiredUpgradeItems.Add("BoneFragments", 4);
			item7.RequiredUpgradeItems.Add("Bronze", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item7.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item8 = new Item("rd_magic", "RDM_bforest_cape");
			item8.Crafting.Add("RDM_mage_table_01", 1);
			item8.RequiredItems.Add("TrollHide", 2);
			item8.RequiredItems.Add("BoneFragments", 4);
			item8.RequiredItems.Add("Bronze", 2);
			item8.RequiredUpgradeItems.Add("TrollHide", 1);
			item8.RequiredUpgradeItems.Add("BoneFragments", 2);
			item8.RequiredUpgradeItems.Add("Bronze", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item8.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item9 = new Item("rd_magic", "RDM_swamp_hat");
			item9.Crafting.Add("RDM_mage_table_01", 2);
			item9.RequiredItems.Add("Iron", 10);
			item9.RequiredItems.Add("ElderBark", 10);
			item9.RequiredItems.Add("Entrails", 6);
			item9.RequiredUpgradeItems.Add("Iron", 2);
			item9.RequiredUpgradeItems.Add("ElderBark", 6);
			item9.RequiredUpgradeItems.Add("Entrails", 3);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item9.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item10 = new Item("rd_magic", "RDM_swamp_chest");
			item10.Crafting.Add("RDM_mage_table_01", 2);
			item10.RequiredItems.Add("Iron", 12);
			item10.RequiredItems.Add("ElderBark", 8);
			item10.RequiredItems.Add("Entrails", 8);
			item10.RequiredUpgradeItems.Add("Iron", 3);
			item10.RequiredUpgradeItems.Add("ElderBark", 4);
			item10.RequiredUpgradeItems.Add("Entrails", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item10.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item11 = new Item("rd_magic", "RDM_swamp_legs");
			item11.Crafting.Add("RDM_mage_table_01", 2);
			item11.RequiredItems.Add("Iron", 12);
			item11.RequiredItems.Add("ElderBark", 8);
			item11.RequiredItems.Add("Entrails", 8);
			item11.RequiredUpgradeItems.Add("Iron", 3);
			item11.RequiredUpgradeItems.Add("ElderBark", 4);
			item11.RequiredUpgradeItems.Add("Entrails", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item11.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item12 = new Item("rd_magic", "RDM_swamp_cape");
			item12.Crafting.Add("RDM_mage_table_01", 2);
			item12.RequiredItems.Add("ElderBark", 4);
			item12.RequiredItems.Add("Entrails", 6);
			item12.RequiredUpgradeItems.Add("ElderBark", 2);
			item12.RequiredUpgradeItems.Add("Entrails", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item12.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item13 = new Item("rd_magic", "RDM_mountain_hat");
			item13.Crafting.Add("RDM_mage_table_01", 2);
			item13.RequiredItems.Add("WolfFang", 3);
			item13.RequiredItems.Add("WolfPelt", 10);
			item13.RequiredItems.Add("FreezeGland", 6);
			item13.RequiredItems.Add("TrollHide", 6);
			item13.RequiredUpgradeItems.Add("WolfPelt", 6);
			item13.RequiredUpgradeItems.Add("FreezeGland", 2);
			item13.RequiredUpgradeItems.Add("TrollHide", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item13.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item14 = new Item("rd_magic", "RDM_mountain_chest");
			item14.Crafting.Add("RDM_mage_table_01", 2);
			item14.RequiredItems.Add("WolfClaw", 3);
			item14.RequiredItems.Add("WolfPelt", 14);
			item14.RequiredItems.Add("Silver", 18);
			item14.RequiredItems.Add("DeerHide", 12);
			item14.RequiredUpgradeItems.Add("WolfPelt", 6);
			item14.RequiredUpgradeItems.Add("Silver", 8);
			item14.RequiredUpgradeItems.Add("DeerHide", 6);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item14.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item15 = new Item("rd_magic", "RDM_mountain_legs");
			item15.Crafting.Add("RDM_mage_table_01", 2);
			item15.RequiredItems.Add("WolfClaw", 3);
			item15.RequiredItems.Add("WolfPelt", 12);
			item15.RequiredItems.Add("Silver", 24);
			item15.RequiredItems.Add("DeerHide", 16);
			item15.RequiredUpgradeItems.Add("WolfPelt", 6);
			item15.RequiredUpgradeItems.Add("Silver", 12);
			item15.RequiredUpgradeItems.Add("DeerHide", 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item15.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item16 = new Item("rd_magic", "RDM_mountain_cape");
			item16.Crafting.Add("RDM_mage_table_01", 2);
			item16.RequiredItems.Add("WolfPelt", 12);
			item16.RequiredItems.Add("Silver", 6);
			item16.RequiredItems.Add("FreezeGland", 6);
			item16.RequiredUpgradeItems.Add("WolfPelt", 6);
			item16.RequiredUpgradeItems.Add("Silver", 4);
			item16.RequiredUpgradeItems.Add("FreezeGland", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item16.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item17 = new Item("rd_magic", "RDM_plains_hat");
			item17.Crafting.Add("RDM_mage_table_01", 2);
			item17.RequiredItems.Add("BlackMetal", 16);
			item17.RequiredItems.Add("LoxPelt", 8);
			item17.RequiredItems.Add("LinenThread", 6);
			item17.RequiredItems.Add("JuteRed", 4);
			item17.RequiredUpgradeItems.Add("BlackMetal", 8);
			item17.RequiredUpgradeItems.Add("LoxPelt", 4);
			item17.RequiredUpgradeItems.Add("LinenThread", 3);
			item17.RequiredUpgradeItems.Add("JuteRed", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item17.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item18 = new Item("rd_magic", "RDM_plains_chest");
			item18.Crafting.Add("RDM_mage_table_01", 2);
			item18.RequiredItems.Add("BlackMetal", 24);
			item18.RequiredItems.Add("LoxPelt", 12);
			item18.RequiredItems.Add("LinenThread", 12);
			item18.RequiredItems.Add("JuteRed", 4);
			item18.RequiredUpgradeItems.Add("BlackMetal", 12);
			item18.RequiredUpgradeItems.Add("LoxPelt", 6);
			item18.RequiredUpgradeItems.Add("LinenThread", 6);
			item18.RequiredUpgradeItems.Add("JuteRed", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item18.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item19 = new Item("rd_magic", "RDM_plains_legs");
			item19.Crafting.Add("RDM_mage_table_01", 2);
			item19.RequiredItems.Add("BlackMetal", 24);
			item19.RequiredItems.Add("LoxPelt", 12);
			item19.RequiredItems.Add("LinenThread", 12);
			item19.RequiredItems.Add("JuteRed", 4);
			item19.RequiredUpgradeItems.Add("BlackMetal", 12);
			item19.RequiredUpgradeItems.Add("LoxPelt", 6);
			item19.RequiredUpgradeItems.Add("LinenThread", 6);
			item19.RequiredUpgradeItems.Add("JuteRed", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item19.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item20 = new Item("rd_magic", "RDM_plains_cape");
			item20.Crafting.Add("RDM_mage_table_01", 2);
			item20.RequiredItems.Add("BlackMetal", 8);
			item20.RequiredItems.Add("LoxPelt", 6);
			item20.RequiredItems.Add("LinenThread", 8);
			item20.RequiredItems.Add("JuteRed", 2);
			item20.RequiredUpgradeItems.Add("BlackMetal", 4);
			item20.RequiredUpgradeItems.Add("LoxPelt", 2);
			item20.RequiredUpgradeItems.Add("LinenThread", 4);
			item20.RequiredUpgradeItems.Add("JuteRed", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item20.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item21 = new Item("rd_magic", "RDM_mistlands_hat");
			item21.Crafting.Add("RDM_mage_table_02", 1);
			item21.RequiredItems.Add("LinenThread", 16);
			item21.RequiredItems.Add("ScaleHide", 12);
			item21.RequiredItems.Add("Carapace", 8);
			item21.RequiredItems.Add("Eitr", 14);
			item21.RequiredUpgradeItems.Add("ScaleHide", 6);
			item21.RequiredUpgradeItems.Add("Carapace", 4);
			item21.RequiredUpgradeItems.Add("Eitr", 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item21.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item22 = new Item("rd_magic", "RDM_mistlands_chest");
			item22.Crafting.Add("RDM_mage_table_02", 1);
			item22.RequiredItems.Add("Mandible", 8);
			item22.RequiredItems.Add("ScaleHide", 18);
			item22.RequiredItems.Add("Carapace", 16);
			item22.RequiredItems.Add("Eitr", 22);
			item22.RequiredUpgradeItems.Add("ScaleHide", 9);
			item22.RequiredUpgradeItems.Add("Carapace", 8);
			item22.RequiredUpgradeItems.Add("Eitr", 11);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item22.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item23 = new Item("rd_magic", "RDM_mistlands_legs");
			item23.Crafting.Add("RDM_mage_table_02", 1);
			item23.RequiredItems.Add("Mandible", 8);
			item23.RequiredItems.Add("ScaleHide", 18);
			item23.RequiredItems.Add("Carapace", 16);
			item23.RequiredItems.Add("Eitr", 22);
			item23.RequiredUpgradeItems.Add("ScaleHide", 9);
			item23.RequiredUpgradeItems.Add("Carapace", 8);
			item23.RequiredUpgradeItems.Add("Eitr", 11);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item23.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item24 = new Item("rd_magic", "RDM_mistlands_cape");
			item24.Crafting.Add("RDM_mage_table_02", 1);
			item24.RequiredItems.Add("Mandible", 2);
			item24.RequiredItems.Add("ScaleHide", 8);
			item24.RequiredItems.Add("Carapace", 8);
			item24.RequiredItems.Add("Eitr", 12);
			item24.RequiredUpgradeItems.Add("ScaleHide", 4);
			item24.RequiredUpgradeItems.Add("Carapace", 4);
			item24.RequiredUpgradeItems.Add("Eitr", 6);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item24.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item25 = new Item("rd_magic", "RDM_ashlands_hat");
			item25.Crafting.Add("RDM_mage_table_02", 1);
			item25.RequiredItems.Add("GemstoneRed", 1);
			item25.RequiredItems.Add("AskHide", 8);
			item25.RequiredItems.Add("CelestialFeather", 4);
			item25.RequiredItems.Add("FlametalNew", 8);
			item25.RequiredUpgradeItems.Add("AskHide", 4);
			item25.RequiredUpgradeItems.Add("CelestialFeather", 2);
			item25.RequiredUpgradeItems.Add("FlametalNew", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item25.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item26 = new Item("rd_magic", "RDM_ashlands_chest");
			item26.Crafting.Add("RDM_mage_table_02", 1);
			item26.RequiredItems.Add("GemstoneRed", 1);
			item26.RequiredItems.Add("AskHide", 28);
			item26.RequiredItems.Add("CharredBone", 16);
			item26.RequiredItems.Add("FlametalNew", 26);
			item26.RequiredUpgradeItems.Add("AskHide", 14);
			item26.RequiredUpgradeItems.Add("CharredBone", 8);
			item26.RequiredUpgradeItems.Add("FlametalNew", 14);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item26.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item27 = new Item("rd_magic", "RDM_ashlands_legs");
			item27.Crafting.Add("RDM_mage_table_02", 1);
			item27.RequiredItems.Add("GemstoneRed", 1);
			item27.RequiredItems.Add("AskHide", 28);
			item27.RequiredItems.Add("CharredBone", 16);
			item27.RequiredItems.Add("FlametalNew", 26);
			item27.RequiredUpgradeItems.Add("AskHide", 14);
			item27.RequiredUpgradeItems.Add("CharredBone", 8);
			item27.RequiredUpgradeItems.Add("FlametalNew", 14);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item27.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item28 = new Item("rd_magic", "RDM_ashlands_cape");
			item28.Crafting.Add("RDM_mage_table_02", 1);
			item28.RequiredItems.Add("GemstoneRed", 1);
			item28.RequiredItems.Add("AskHide", 6);
			item28.RequiredItems.Add("CelestialFeather", 6);
			item28.RequiredItems.Add("FlametalNew", 12);
			item28.RequiredUpgradeItems.Add("AskHide", 3);
			item28.RequiredUpgradeItems.Add("CelestialFeather", 4);
			item28.RequiredUpgradeItems.Add("FlametalNew", 6);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item28.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
		}
	}
	internal static class Registrations_ArmorHealer
	{
		public static void RegisterArmorHealer()
		{
			Item item = new Item("rd_magic", "RDM_bforest_healer_helmet");
			item.Crafting.Add("RDM_mage_table_01", 1);
			item.RequiredItems.Add("TrollHide", 4);
			item.RequiredItems.Add("BoneFragments", 6);
			item.RequiredItems.Add("Bronze", 5);
			item.RequiredUpgradeItems.Add("TrollHide", 1);
			item.RequiredUpgradeItems.Add("BoneFragments", 2);
			item.RequiredUpgradeItems.Add("Bronze", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item2 = new Item("rd_magic", "RDM_bforest_healer_chest");
			item2.Crafting.Add("RDM_mage_table_01", 1);
			item2.RequiredItems.Add("TrollHide", 4);
			item2.RequiredItems.Add("BoneFragments", 8);
			item2.RequiredItems.Add("Bronze", 5);
			item2.RequiredUpgradeItems.Add("TrollHide", 1);
			item2.RequiredUpgradeItems.Add("BoneFragments", 3);
			item2.RequiredUpgradeItems.Add("Bronze", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item2.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item3 = new Item("rd_magic", "RDM_bforest_healer_legs");
			item3.Crafting.Add("RDM_mage_table_01", 1);
			item3.RequiredItems.Add("TrollHide", 4);
			item3.RequiredItems.Add("BoneFragments", 6);
			item3.RequiredItems.Add("Bronze", 5);
			item3.RequiredUpgradeItems.Add("TrollHide", 1);
			item3.RequiredUpgradeItems.Add("BoneFragments", 4);
			item3.RequiredUpgradeItems.Add("Bronze", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item3.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item4 = new Item("rd_magic", "RDM_bforest_healer_cape");
			item4.Crafting.Add("RDM_mage_table_01", 1);
			item4.RequiredItems.Add("TrollHide", 2);
			item4.RequiredItems.Add("BoneFragments", 4);
			item4.RequiredItems.Add("Bronze", 2);
			item4.RequiredUpgradeItems.Add("TrollHide", 1);
			item4.RequiredUpgradeItems.Add("BoneFragments", 2);
			item4.RequiredUpgradeItems.Add("Bronze", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item4.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item5 = new Item("rd_magic", "RDM_mountain_healer_helmet");
			item5.Crafting.Add("RDM_mage_table_01", 2);
			item5.RequiredItems.Add("WolfFang", 3);
			item5.RequiredItems.Add("WolfPelt", 10);
			item5.RequiredItems.Add("FreezeGland", 6);
			item5.RequiredItems.Add("TrollHide", 6);
			item5.RequiredUpgradeItems.Add("WolfPelt", 6);
			item5.RequiredUpgradeItems.Add("FreezeGland", 2);
			item5.RequiredUpgradeItems.Add("TrollHide", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item5.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item6 = new Item("rd_magic", "RDM_mountain_healer_chest");
			item6.Crafting.Add("RDM_mage_table_01", 2);
			item6.RequiredItems.Add("WolfClaw", 3);
			item6.RequiredItems.Add("WolfPelt", 14);
			item6.RequiredItems.Add("Silver", 18);
			item6.RequiredItems.Add("DeerHide", 12);
			item6.RequiredUpgradeItems.Add("WolfPelt", 6);
			item6.RequiredUpgradeItems.Add("Silver", 8);
			item6.RequiredUpgradeItems.Add("DeerHide", 6);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item6.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item7 = new Item("rd_magic", "RDM_mountain_healer_legs");
			item7.Crafting.Add("RDM_mage_table_01", 2);
			item7.RequiredItems.Add("WolfClaw", 3);
			item7.RequiredItems.Add("WolfPelt", 12);
			item7.RequiredItems.Add("Silver", 24);
			item7.RequiredItems.Add("DeerHide", 16);
			item7.RequiredUpgradeItems.Add("WolfPelt", 6);
			item7.RequiredUpgradeItems.Add("Silver", 12);
			item7.RequiredUpgradeItems.Add("DeerHide", 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item7.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item8 = new Item("rd_magic", "RDM_mountain_healer_cape");
			item8.Crafting.Add("RDM_mage_table_01", 2);
			item8.RequiredItems.Add("WolfPelt", 12);
			item8.RequiredItems.Add("Silver", 6);
			item8.RequiredItems.Add("FreezeGland", 6);
			item8.RequiredUpgradeItems.Add("WolfPelt", 6);
			item8.RequiredUpgradeItems.Add("Silver", 4);
			item8.RequiredUpgradeItems.Add("FreezeGland", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item8.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item9 = new Item("rd_magic", "RDM_mistlands_healer_helmet");
			item9.Crafting.Add("RDM_mage_table_02", 1);
			item9.RequiredItems.Add("LinenThread", 16);
			item9.RequiredItems.Add("ScaleHide", 12);
			item9.RequiredItems.Add("Carapace", 8);
			item9.RequiredItems.Add("Eitr", 14);
			item9.RequiredUpgradeItems.Add("ScaleHide", 6);
			item9.RequiredUpgradeItems.Add("Carapace", 4);
			item9.RequiredUpgradeItems.Add("Eitr", 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item9.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item10 = new Item("rd_magic", "RDM_mistlands_healer_chest");
			item10.Crafting.Add("RDM_mage_table_02", 1);
			item10.RequiredItems.Add("Mandible", 8);
			item10.RequiredItems.Add("ScaleHide", 18);
			item10.RequiredItems.Add("Carapace", 16);
			item10.RequiredItems.Add("Eitr", 22);
			item10.RequiredUpgradeItems.Add("ScaleHide", 9);
			item10.RequiredUpgradeItems.Add("Carapace", 8);
			item10.RequiredUpgradeItems.Add("Eitr", 11);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item10.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item11 = new Item("rd_magic", "RDM_mistlands_healer_legs");
			item11.Crafting.Add("RDM_mage_table_02", 1);
			item11.RequiredItems.Add("Mandible", 8);
			item11.RequiredItems.Add("ScaleHide", 18);
			item11.RequiredItems.Add("Carapace", 16);
			item11.RequiredItems.Add("Eitr", 22);
			item11.RequiredUpgradeItems.Add("ScaleHide", 9);
			item11.RequiredUpgradeItems.Add("Carapace", 8);
			item11.RequiredUpgradeItems.Add("Eitr", 11);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item11.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item12 = new Item("rd_magic", "RDM_mistlands_healer_cape");
			item12.Crafting.Add("RDM_mage_table_02", 1);
			item12.RequiredItems.Add("Mandible", 2);
			item12.RequiredItems.Add("ScaleHide", 8);
			item12.RequiredItems.Add("Carapace", 8);
			item12.RequiredItems.Add("Eitr", 12);
			item12.RequiredUpgradeItems.Add("ScaleHide", 4);
			item12.RequiredUpgradeItems.Add("Carapace", 4);
			item12.RequiredUpgradeItems.Add("Eitr", 6);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item12.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
		}
	}
	internal static class Registrations_BookHeal
	{
		public static void RegisterBookHeal()
		{
			Item item = new Item("rd_magic", "RDM_book_heal_01");
			item.Crafting.Add("RDM_mage_table_01", 1);
			item.RequiredItems.Add("Bronze", 20);
			item.RequiredItems.Add("AncientSeed", 10);
			item.RequiredItems.Add("TrophyFrostTroll", 5);
			item.RequiredUpgradeItems.Add("Bronze", 5);
			item.RequiredUpgradeItems.Add("AncientSeed", 2);
			item.RequiredUpgradeItems.Add("TrophyFrostTroll", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item2 = new Item("rd_magic", "RDM_book_heal_02");
			item2.Crafting.Add("RDM_mage_table_01", 1);
			item2.RequiredItems.Add("JuteRed", 10);
			item2.RequiredItems.Add("WolfFang", 20);
			item2.RequiredItems.Add("TrophyCultist", 5);
			item2.RequiredUpgradeItems.Add("JuteRed", 5);
			item2.RequiredUpgradeItems.Add("WolfFang", 10);
			item2.RequiredUpgradeItems.Add("TrophyCultist", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item2.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item3 = new Item("rd_magic", "RDM_book_heal_03");
			item3.Crafting.Add("RDM_mage_table_02", 1);
			item3.RequiredItems.Add("Eitr", 30);
			item3.RequiredItems.Add("BlackCore", 5);
			item3.RequiredItems.Add("TrophyDvergr", 5);
			item3.RequiredUpgradeItems.Add("Eitr", 15);
			item3.RequiredUpgradeItems.Add("BlackCore", 1);
			item3.RequiredUpgradeItems.Add("TrophyDvergr", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item3.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
		}
	}
	internal static class Registrations_BottleWater
	{
		public static void RegisterBottleWater()
		{
			Item item = new Item("rd_magic", "RDM_water_bootle_empty");
			item.Crafting.Add(ItemManager.CraftingTable.Workbench, 1);
			item.CraftAmount = 10;
			item.RequiredItems.Add("Flint", 1);
			item.RequiredItems.Add("Resin", 1);
			item.RequiredItems.Add("LeatherScraps", 1);
			Item item2 = new Item("rd_magic", "RDM_water_bootle_full");
		}
	}
	internal static class Registrations_Codex
	{
		public static void RegisterCodex()
		{
			Item item = new Item("rd_magic", "RDM_codex_fire_01");
			item.Crafting.Add("RDM_mage_table_01", 2);
			item.RequiredItems.Add("Bronze", 12);
			item.RequiredItems.Add("AncientSeed", 10);
			item.RequiredItems.Add("SurtlingCore", 5);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item2 = new Item("rd_magic", "RDM_codex_fire_02");
			item2.Crafting.Add("RDM_mage_table_01", 3);
			item2.RequiredItems.Add("Silver", 20);
			item2.RequiredItems.Add("WolfPelt", 18);
			item2.RequiredItems.Add("TrophyCultist", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item2.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item3 = new Item("rd_magic", "RDM_codex_fire_03");
			item3.Crafting.Add("RDM_mage_table_02", 1);
			item3.RequiredItems.Add("Eitr", 20);
			item3.RequiredItems.Add("Carapace", 20);
			item3.RequiredItems.Add("TrophySkeletonHildir", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item3.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item4 = new Item("rd_magic", "RDM_codex_thunder_01");
			item4.Crafting.Add("RDM_mage_table_01", 2);
			item4.RequiredItems.Add("Bronze", 12);
			item4.RequiredItems.Add("AncientSeed", 10);
			item4.RequiredItems.Add("HardAntler", 5);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item4.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item5 = new Item("rd_magic", "RDM_codex_thunder_02");
			item5.Crafting.Add("RDM_mage_table_01", 3);
			item5.RequiredItems.Add("Silver", 20);
			item5.RequiredItems.Add("WolfPelt", 18);
			item5.RequiredItems.Add("Thunderstone", 3);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item5.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item6 = new Item("rd_magic", "RDM_codex_thunder_03");
			item6.Crafting.Add("RDM_mage_table_02", 1);
			item6.RequiredItems.Add("Eitr", 20);
			item6.RequiredItems.Add("Carapace", 20);
			item6.RequiredItems.Add("TrophyGoblinBruteBrosBrute", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item6.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item7 = new Item("rd_magic", "RDM_codex_ice_01");
			item7.Crafting.Add("RDM_mage_table_01", 2);
			item7.RequiredItems.Add("Bronze", 12);
			item7.RequiredItems.Add("AncientSeed", 10);
			item7.RequiredItems.Add("TrophyFrostTroll", 3);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item7.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item8 = new Item("rd_magic", "RDM_codex_ice_02");
			item8.Crafting.Add("RDM_mage_table_01", 3);
			item8.RequiredItems.Add("Silver", 20);
			item8.RequiredItems.Add("WolfPelt", 18);
			item8.RequiredItems.Add("TrophySGolem", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item8.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item9 = new Item("rd_magic", "RDM_codex_ice_03");
			item9.Crafting.Add("RDM_mage_table_02", 1);
			item9.RequiredItems.Add("Eitr", 20);
			item9.RequiredItems.Add("Carapace", 20);
			item9.RequiredItems.Add("TrophyCultist_Hildir", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item9.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item10 = new Item("rd_magic", "RDM_codex_poison_01");
			item10.Crafting.Add("RDM_mage_table_01", 2);
			item10.RequiredItems.Add("Bronze", 12);
			item10.RequiredItems.Add("AncientSeed", 10);
			item10.RequiredItems.Add("TrophyGreydwarfShaman", 3);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item10.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item11 = new Item("rd_magic", "RDM_codex_poison_02");
			item11.Crafting.Add("RDM_mage_table_01", 3);
			item11.RequiredItems.Add("Silver", 20);
			item11.RequiredItems.Add("WolfPelt", 18);
			item11.RequiredItems.Add("YmirRemains", 5);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item11.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item12 = new Item("rd_magic", "RDM_codex_poison_03");
			item12.Crafting.Add("RDM_mage_table_02", 1);
			item12.RequiredItems.Add("Eitr", 20);
			item12.RequiredItems.Add("Carapace", 20);
			item12.RequiredItems.Add("TrophyGoblinBruteBrosShaman", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item12.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
		}
	}
	internal static class Registrations_Foods
	{
		public static void RegisterFoods()
		{
			Item item = new Item("rd_magic", "RDM_soup_meadows");
			item.Crafting.Add(ItemManager.CraftingTable.Inventory, 1);
			item.RequiredItems.Add("RDM_water_bootle_full", 2);
			item.RequiredItems.Add("RawMeat", 2);
			item.RequiredItems.Add("Dandelion", 4);
			item.RequiredItems.Add("Mushroom", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item2 = new Item("rd_magic", "RDM_soup_bforest");
			item2.Crafting.Add(ItemManager.CraftingTable.Cauldron, 1);
			item2.RequiredItems.Add("RDM_water_bootle_full", 2);
			item2.RequiredItems.Add("Thistle", 3);
			item2.RequiredItems.Add("MushroomYellow", 4);
			item2.RequiredItems.Add("Carrot", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item2.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item3 = new Item("rd_magic", "RDM_soup_swamp");
			item3.Crafting.Add(ItemManager.CraftingTable.Cauldron, 2);
			item3.RequiredItems.Add("RDM_water_bootle_full", 2);
			item3.RequiredItems.Add("Bloodbag", 2);
			item3.RequiredItems.Add("Entrails", 4);
			item3.RequiredItems.Add("Turnip", 6);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item3.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item4 = new Item("rd_magic", "RDM_soup_mountain");
			item4.Crafting.Add(ItemManager.CraftingTable.Cauldron, 3);
			item4.RequiredItems.Add("RDM_water_bootle_full", 2);
			item4.RequiredItems.Add("Onion", 5);
			item4.RequiredItems.Add("AncientSeed", 3);
			item4.RequiredItems.Add("WolfMeat", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item4.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item5 = new Item("rd_magic", "RDM_soup_plains");
			item5.Crafting.Add(ItemManager.CraftingTable.Cauldron, 4);
			item5.RequiredItems.Add("RDM_water_bootle_full", 2);
			item5.RequiredItems.Add("BarleyFlour", 6);
			item5.RequiredItems.Add("Cloudberry", 4);
			item5.RequiredItems.Add("ChickenEgg", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item5.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item6 = new Item("rd_magic", "RDM_mead_meadows");
			item6.Crafting.Add(ItemManager.CraftingTable.Inventory, 1);
			item6.RequiredItems.Add("RDM_water_bootle_full", 1);
			item6.RequiredItems.Add("Raspberry", 5);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item6.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item7 = new Item("rd_magic", "RDM_mead_bforest");
			item7.Crafting.Add(ItemManager.CraftingTable.Cauldron, 1);
			item7.RequiredItems.Add("RDM_water_bootle_full", 1);
			item7.RequiredItems.Add("Blueberries", 5);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item7.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item8 = new Item("rd_magic", "RDM_mead_swamp");
			item8.Crafting.Add(ItemManager.CraftingTable.Cauldron, 2);
			item8.RequiredItems.Add("RDM_water_bootle_full", 1);
			item8.RequiredItems.Add("Turnip", 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item8.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item9 = new Item("rd_magic", "RDM_mead_mountain");
			item9.Crafting.Add(ItemManager.CraftingTable.Cauldron, 3);
			item9.RequiredItems.Add("RDM_water_bootle_full", 1);
			item9.RequiredItems.Add("FreezeGland", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item9.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item10 = new Item("rd_magic", "RDM_mead_plains");
			item10.Crafting.Add(ItemManager.CraftingTable.Cauldron, 4);
			item10.RequiredItems.Add("RDM_water_bootle_full", 1);
			item10.RequiredItems.Add("Cloudberry", 10);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item10.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item11 = new Item("rd_magic", "RDM_drink_01");
			item11.Crafting.Add(ItemManager.CraftingTable.Cauldron, 1);
			item11.RequiredItems.Add("RDM_water_bootle_full", 1);
			item11.RequiredItems.Add("Thistle", 5);
			item11.RequiredItems.Add("AncientSeed", 2);
			item11.RequiredItems.Add("MushroomYellow", 5);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item11.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item12 = new Item("rd_magic", "RDM_drink_02");
			item12.Crafting.Add(ItemManager.CraftingTable.Cauldron, 2);
			item12.RequiredItems.Add("RDM_water_bootle_full", 1);
			item12.RequiredItems.Add("Root", 2);
			item12.RequiredItems.Add("Guck", 6);
			item12.RequiredItems.Add("Ooze", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item12.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item13 = new Item("rd_magic", "RDM_drink_03");
			item13.Crafting.Add(ItemManager.CraftingTable.Cauldron, 3);
			item13.RequiredItems.Add("RDM_water_bootle_full", 1);
			item13.RequiredItems.Add("Crystal", 2);
			item13.RequiredItems.Add("FreezeGland", 4);
			item13.RequiredItems.Add("Blueberries", 6);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item13.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
		}
	}
	internal static class Registrations_GameObjects
	{
		public static void RegisterGameObjects()
		{
			GameObject val = PrefabManager.RegisterPrefab("rd_magic", "fx_projectile_begin_explosion");
			GameObject val2 = PrefabManager.RegisterPrefab("rd_magic", "fx_projectile_meadows_explosion");
			GameObject val3 = PrefabManager.RegisterPrefab("rd_magic", "fx_nova_ring_meadows");
			GameObject val4 = PrefabManager.RegisterPrefab("rd_magic", "fx_projectile_bforest_explosion");
			GameObject val5 = PrefabManager.RegisterPrefab("rd_magic", "fx_nova_ring_bforest");
			GameObject val6 = PrefabManager.RegisterPrefab("rd_magic", "fx_projectile_swamp_explosion");
			GameObject val7 = PrefabManager.RegisterPrefab("rd_magic", "fx_nova_ring_swamp");
			GameObject val8 = PrefabManager.RegisterPrefab("rd_magic", "fx_projectile_mountain_explosion");
			GameObject val9 = PrefabManager.RegisterPrefab("rd_magic", "fx_nova_ring_mountain");
			GameObject val10 = PrefabManager.RegisterPrefab("rd_magic", "fx_projectile_plains_explosion");
			GameObject val11 = PrefabManager.RegisterPrefab("rd_magic", "fx_nova_ring_plains");
			GameObject val12 = PrefabManager.RegisterPrefab("rd_magic", "fx_projectile_mistlands_explosion");
			GameObject val13 = PrefabManager.RegisterPrefab("rd_magic", "fx_nova_ring_mistlands");
			GameObject val14 = PrefabManager.RegisterPrefab("rd_magic", "fx_projectile_ashlands_explosion");
			GameObject val15 = PrefabManager.RegisterPrefab("rd_magic", "fx_nova_ring_ashlands");
			GameObject val16 = PrefabManager.RegisterPrefab("rd_magic", "sfx_staff_launch_begin_rd_magic");
			GameObject val17 = PrefabManager.RegisterPrefab("rd_magic", "sfx_staff_launch_meadows_rd_magic");
			GameObject val18 = PrefabManager.RegisterPrefab("rd_magic", "sfx_staff_launch_bforest_rd_magic");
			GameObject val19 = PrefabManager.RegisterPrefab("rd_magic", "sfx_staff_launch_swamp_rd_magic");
			GameObject val20 = PrefabManager.RegisterPrefab("rd_magic", "sfx_staff_launch_mountain_rd_magic");
			GameObject val21 = PrefabManager.RegisterPrefab("rd_magic", "sfx_staff_launch_plains_rd_magic");
			GameObject val22 = PrefabManager.RegisterPrefab("rd_magic", "sfx_staff_launch_mistlands_rd_magic");
			GameObject val23 = PrefabManager.RegisterPrefab("rd_magic", "sfx_staff_launch_ashlands_rd_magic");
			GameObject val24 = PrefabManager.RegisterPrefab("rd_magic", "sfx_wood_blocked_rd_magic");
			GameObject val25 = PrefabManager.RegisterPrefab("rd_magic", "vfx_blocked_rd_magic");
			GameObject val26 = PrefabManager.RegisterPrefab("rd_magic", "fx_block_camshake_rd_magic");
			GameObject val27 = PrefabManager.RegisterPrefab("rd_magic", "sfx_bomb_throw_rd_magic");
			GameObject val28 = PrefabManager.RegisterPrefab("rd_magic", "fx_goblinking_meteor_hit_rd_magic");
			GameObject val29 = PrefabManager.RegisterPrefab("rd_magic", "sfx_staff_launch_plains_wand_rd_magic");
			GameObject val30 = PrefabManager.RegisterPrefab("rd_magic", "sfx_staff_launch_bforest_wand_rd_magic");
			GameObject val31 = PrefabManager.RegisterPrefab("rd_magic", "sfx_staff_launch_swamp_wand_rd_magic");
			GameObject val32 = PrefabManager.RegisterPrefab("rd_magic", "sfx_staff_launch_mountain_wand_rd_magic");
			GameObject val33 = PrefabManager.RegisterPrefab("rd_magic", "fx_projectile_wand_plains_explosion");
			GameObject val34 = PrefabManager.RegisterPrefab("rd_magic", "fx_projectile_wand_bforest_explosion");
			GameObject val35 = PrefabManager.RegisterPrefab("rd_magic", "fx_projectile_wand_swamp_explosion");
			GameObject val36 = PrefabManager.RegisterPrefab("rd_magic", "fx_projectile_wand_mountain_explosion");
			GameObject val37 = PrefabManager.RegisterPrefab("rd_magic", "sfx_gui_craftitem_workbench_rd_magic");
			GameObject val38 = PrefabManager.RegisterPrefab("rd_magic", "sfx_gui_craftitem_workbench_end_rd_magic");
			GameObject val39 = PrefabManager.RegisterPrefab("rd_magic", "sfx_gui_repairitem_workbench_rd_magic");
			GameObject val40 = PrefabManager.RegisterPrefab("rd_magic", "vfx_SawDust_rd_magic");
			GameObject val41 = PrefabManager.RegisterPrefab("rd_magic", "sfx_wood_destroyed_rd_magic");
			GameObject val42 = PrefabManager.RegisterPrefab("rd_magic", "vfx_Place_workbench_rd_magic");
			GameObject val43 = PrefabManager.RegisterPrefab("rd_magic", "sfx_build_hammer_wood_rd_magic");
			GameObject val44 = PrefabManager.RegisterPrefab("rd_magic", "vfx_Place_stone_wall_2x1_rd_magic");
			GameObject val45 = PrefabManager.RegisterPrefab("rd_magic", "vfx_ExtensionConnection_rd_magic");
			GameObject val46 = PrefabManager.RegisterPrefab("rd_magic", "sfx_drink_rd_magic");
			GameObject val47 = PrefabManager.RegisterPrefab("rd_magic", "fx_Eat_rd_magic");
			GameObject val48 = PrefabManager.RegisterPrefab("rd_magic", "fx_FeastSmall_rd_magic");
			GameObject val49 = PrefabManager.RegisterPrefab("rd_magic", "sfx_eat_rd_magic");
			GameObject val50 = PrefabManager.RegisterPrefab("rd_magic", "sfx_unarmed_hit_rd_magic");
			GameObject val51 = PrefabManager.RegisterPrefab("rd_magic", "vfx_Place_wood_pole_rd_magic");
			GameObject val52 = PrefabManager.RegisterPrefab("rd_magic", "vfx_Potion_health_medium_rd_magic");
			GameObject val53 = PrefabManager.RegisterPrefab("rd_magic", "sfx_Potion_health_large_rd_magic");
			GameObject val54 = PrefabManager.RegisterPrefab("rd_magic", "sfx_water_bottle_rd_magic");
			GameObject val55 = PrefabManager.RegisterPrefab("rd_magic", "fx_heal_start_01_rd_magic");
			GameObject val56 = PrefabManager.RegisterPrefab("rd_magic", "fx_heal_start_02_rd_magic");
			GameObject val57 = PrefabManager.RegisterPrefab("rd_magic", "fx_heal_start_03_rd_magic");
			GameObject val58 = PrefabManager.RegisterPrefab("rd_magic", "fx_equip_set_healer_01");
			GameObject val59 = PrefabManager.RegisterPrefab("rd_magic", "fx_equip_set_healer_02");
			GameObject val60 = PrefabManager.RegisterPrefab("rd_magic", "fx_equip_set_healer_03");
			GameObject val61 = PrefabManager.RegisterPrefab("rd_magic", "vfx_orb_shield_bforest");
			GameObject val62 = PrefabManager.RegisterPrefab("rd_magic", "vfx_orb_shield_swamp");
			GameObject val63 = PrefabManager.RegisterPrefab("rd_magic", "vfx_orb_shield_mountain");
			GameObject val64 = PrefabManager.RegisterPrefab("rd_magic", "vfx_orb_shield_plains");
			GameObject val65 = PrefabManager.RegisterPrefab("rd_magic", "sfx_incantation_staff_launch_meadows_rd_magic");
			GameObject val66 = PrefabManager.RegisterPrefab("rd_magic", "sfx_incantation_staff_launch_bforest_rd_magic");
			GameObject val67 = PrefabManager.RegisterPrefab("rd_magic", "sfx_incantation_staff_launch_swamp_rd_magic");
			GameObject val68 = PrefabManager.RegisterPrefab("rd_magic", "sfx_incantation_staff_launch_mountain_rd_magic");
			GameObject val69 = PrefabManager.RegisterPrefab("rd_magic", "sfx_incantation_staff_launch_plains_rd_magic");
			GameObject val70 = PrefabManager.RegisterPrefab("rd_magic", "sfx_incantation_staff_launch_mistlands_rd_magic");
			GameObject val71 = PrefabManager.RegisterPrefab("rd_magic", "sfx_incantation_staff_launch_ashlands_rd_magic");
			GameObject val72 = PrefabManager.RegisterPrefab("rd_magic", "projectile_begin");
			GameObject val73 = PrefabManager.RegisterPrefab("rd_magic", "projectile_meadows");
			GameObject val74 = PrefabManager.RegisterPrefab("rd_magic", "projectile_nova_aoe_meadows");
			GameObject val75 = PrefabManager.RegisterPrefab("rd_magic", "projectile_bforest");
			GameObject val76 = PrefabManager.RegisterPrefab("rd_magic", "projectile_nova_aoe_bforest");
			GameObject val77 = PrefabManager.RegisterPrefab("rd_magic", "projectile_swamp");
			GameObject val78 = PrefabManager.RegisterPrefab("rd_magic", "projectile_nova_aoe_swamp");
			GameObject val79 = PrefabManager.RegisterPrefab("rd_magic", "projectile_mountain");
			GameObject val80 = PrefabManager.RegisterPrefab("rd_magic", "projectile_nova_aoe_mountain");
			GameObject val81 = PrefabManager.RegisterPrefab("rd_magic", "projectile_plains");
			GameObject val82 = PrefabManager.RegisterPrefab("rd_magic", "projectile_meteor_plains");
			GameObject val83 = PrefabManager.RegisterPrefab("rd_magic", "projectile_meteor_spawn");
			GameObject val84 = PrefabManager.RegisterPrefab("rd_magic", "projectile_mistlands");
			GameObject val85 = PrefabManager.RegisterPrefab("rd_magic", "projectile_nova_aoe_mistlands");
			GameObject val86 = PrefabManager.RegisterPrefab("rd_magic", "projectile_ashlands");
			GameObject val87 = PrefabManager.RegisterPrefab("rd_magic", "projectile_nova_aoe_ashlands");
			GameObject val88 = PrefabManager.RegisterPrefab("rd_magic", "projectile_wand_plains");
			GameObject val89 = PrefabManager.RegisterPrefab("rd_magic", "projectile_wand_bforest");
			GameObject val90 = PrefabManager.RegisterPrefab("rd_magic", "projectile_wand_swamp");
			GameObject val91 = PrefabManager.RegisterPrefab("rd_magic", "projectile_wand_mountain");
			GameObject val92 = PrefabManager.RegisterPrefab("rd_magic", "magic_heal_aoe_01");
			GameObject val93 = PrefabManager.RegisterPrefab("rd_magic", "magic_heal_aoe_02");
			GameObject val94 = PrefabManager.RegisterPrefab("rd_magic", "magic_heal_aoe_03");
		}
	}
	internal static class Registrations_Orbs
	{
		public static void RegisterOrbs()
		{
			Item item = new Item("rd_magic", "RDM_protection_orb_bforest");
			item.Crafting.Add("RDM_mage_table_01", 2);
			item.RequiredItems.Add("RoundLog", 10);
			item.RequiredItems.Add("HardAntler", 3);
			item.RequiredItems.Add("Bronze", 6);
			item.RequiredUpgradeItems.Add("RoundLog", 5);
			item.RequiredUpgradeItems.Add("HardAntler", 1);
			item.RequiredUpgradeItems.Add("Bronze", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item2 = new Item("rd_magic", "RDM_protection_orb_swamp");
			item2.Crafting.Add("RDM_mage_table_01", 2);
			item2.RequiredItems.Add("Guck", 10);
			item2.RequiredItems.Add("Iron", 10);
			item2.RequiredItems.Add("ElderBark", 6);
			item2.RequiredUpgradeItems.Add("Guck", 5);
			item2.RequiredUpgradeItems.Add("Iron", 5);
			item2.RequiredUpgradeItems.Add("ElderBark", 3);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item2.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item3 = new Item("rd_magic", "RDM_protection_orb_mountain");
			item3.Crafting.Add("RDM_mage_table_01", 2);
			item3.RequiredItems.Add("RoundLog", 12);
			item3.RequiredItems.Add("FreezeGland", 8);
			item3.RequiredItems.Add("Silver", 10);
			item3.RequiredUpgradeItems.Add("RoundLog", 6);
			item3.RequiredUpgradeItems.Add("FreezeGland", 4);
			item3.RequiredUpgradeItems.Add("Silver", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item3.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item4 = new Item("rd_magic", "RDM_protection_orb_plains");
			item4.Crafting.Add("RDM_mage_table_02", 1);
			item4.RequiredItems.Add("GoblinTotem", 1);
			item4.RequiredItems.Add("LoxPelt", 12);
			item4.RequiredItems.Add("BlackMetal", 10);
			item4.RequiredUpgradeItems.Add("LoxPelt", 6);
			item4.RequiredUpgradeItems.Add("BlackMetal", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item4.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
		}
	}
	internal static class Registrations_Staffs
	{
		public static void RegisterStaffs()
		{
			Item item = new Item("rd_magic", "RDM_staff_begin");
			item.Crafting.Add("RDM_mage_table_01", 1);
			item.RequiredItems.Add("Resin", 10);
			item.RequiredItems.Add("Wood", 20);
			item.RequiredItems.Add("Flint", 5);
			item.RequiredUpgradeItems.Add("Resin", 5);
			item.RequiredUpgradeItems.Add("Wood", 10);
			item.RequiredUpgradeItems.Add("Flint", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item2 = new Item("rd_magic", "RDM_staff_meadows");
			item2.Crafting.Add("RDM_mage_table_01", 1);
			item2.RequiredItems.Add("Wood", 16);
			item2.RequiredItems.Add("GreydwarfEye", 10);
			item2.RequiredItems.Add("HardAntler", 5);
			item2.RequiredUpgradeItems.Add("Wood", 8);
			item2.RequiredUpgradeItems.Add("GreydwarfEye", 4);
			item2.RequiredUpgradeItems.Add("HardAntler", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item2.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item3 = new Item("rd_magic", "RDM_staff_bforest");
			item3.Crafting.Add("RDM_mage_table_01", 2);
			item3.RequiredItems.Add("RoundLog", 20);
			item3.RequiredItems.Add("SurtlingCore", 6);
			item3.RequiredItems.Add("Bronze", 10);
			item3.RequiredUpgradeItems.Add("RoundLog", 10);
			item3.RequiredUpgradeItems.Add("SurtlingCore", 3);
			item3.RequiredUpgradeItems.Add("Bronze", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item3.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item4 = new Item("rd_magic", "RDM_staff_swamp");
			item4.Crafting.Add("RDM_mage_table_01", 2);
			item4.RequiredItems.Add("Guck", 16);
			item4.RequiredItems.Add("Iron", 20);
			item4.RequiredItems.Add("ElderBark", 14);
			item4.RequiredUpgradeItems.Add("Guck", 8);
			item4.RequiredUpgradeItems.Add("Iron", 10);
			item4.RequiredUpgradeItems.Add("ElderBark", 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item4.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item5 = new Item("rd_magic", "RDM_staff_mountain");
			item5.Crafting.Add("RDM_mage_table_01", 2);
			item5.RequiredItems.Add("RoundLog", 22);
			item5.RequiredItems.Add("FreezeGland", 16);
			item5.RequiredItems.Add("Silver", 20);
			item5.RequiredUpgradeItems.Add("RoundLog", 11);
			item5.RequiredUpgradeItems.Add("FreezeGland", 8);
			item5.RequiredUpgradeItems.Add("Silver", 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item5.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item6 = new Item("rd_magic", "RDM_staff_plains");
			item6.Crafting.Add("RDM_mage_table_02", 1);
			item6.RequiredItems.Add("GoblinTotem", 2);
			item6.RequiredItems.Add("LoxPelt", 22);
			item6.RequiredItems.Add("BlackMetal", 20);
			item6.RequiredUpgradeItems.Add("LoxPelt", 11);
			item6.RequiredUpgradeItems.Add("BlackMetal", 8);
			item6.RequiredUpgradeItems.Add("GoblinTotem", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item6.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item7 = new Item("rd_magic", "RDM_staff_mistlands");
			item7.Crafting.Add("RDM_mage_table_02", 1);
			item7.RequiredItems.Add("BlackCore", 5);
			item7.RequiredItems.Add("YggdrasilWood", 22);
			item7.RequiredItems.Add("Eitr", 14);
			item7.RequiredUpgradeItems.Add("YggdrasilWood", 11);
			item7.RequiredUpgradeItems.Add("Eitr", 6);
			item7.RequiredUpgradeItems.Add("BlackCore", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item7.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item8 = new Item("rd_magic", "RDM_staff_ashlands");
			item8.Crafting.Add("RDM_mage_table_02", 1);
			item8.RequiredItems.Add("ShieldCore", 2);
			item8.RequiredItems.Add("YggdrasilWood", 24);
			item8.RequiredItems.Add("FlametalNew", 12);
			item8.RequiredUpgradeItems.Add("YggdrasilWood", 11);
			item8.RequiredUpgradeItems.Add("FlametalNew", 6);
			item8.RequiredUpgradeItems.Add("ShieldCore", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item8.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
		}
	}
	internal static class Registrations_Wands
	{
		public static void RegisterWands()
		{
			Item item = new Item("rd_magic", "RDM_wand_bforest");
			item.Crafting.Add("RDM_mage_table_01", 2);
			item.RequiredItems.Add("RoundLog", 10);
			item.RequiredItems.Add("HardAntler", 3);
			item.RequiredItems.Add("Bronze", 6);
			item.RequiredUpgradeItems.Add("RoundLog", 5);
			item.RequiredUpgradeItems.Add("HardAntler", 1);
			item.RequiredUpgradeItems.Add("Bronze", 2);
			MaterialReplacer.Re