using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using JudesEquipment.ArmorSets;
using JudesEquipment.Configuration;
using UnityEngine;
using YamlDotNet.Serialization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("JudesEquipment")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("JudesEquipment")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("f33c90df-d8e2-403e-b94c-001a58ff0821")]
[assembly: AssemblyFileVersion("3.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("3.0.0.0")]
[module: UnverifiableCode]
namespace JudesEquipment
{
	[HarmonyPatch]
	internal static class GenderSwitchPatch
	{
		[HarmonyPatch(typeof(VisEquipment), "AttachArmor")]
		[HarmonyPostfix]
		public static void PostFix(VisEquipment __instance, ref List<GameObject> __result)
		{
			SetEquipmentGender(ref __result, __instance);
		}

		public static void SetEquipmentGender(ref List<GameObject> equip, VisEquipment viseq)
		{
			foreach (GameObject item in equip)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				for (int i = 0; i < item.transform.childCount; i++)
				{
					Transform child = item.transform.GetChild(i);
					if (!((Object)(object)child == (Object)null))
					{
						if (((Object)((Component)child).gameObject).name == "female" && viseq.GetModelIndex() == 0)
						{
							((Component)child).gameObject.SetActive(false);
						}
						if (((Object)((Component)child).gameObject).name == "male" && viseq.GetModelIndex() == 1)
						{
							((Component)child).gameObject.SetActive(false);
						}
					}
				}
			}
		}
	}
	public static class ItemManager
	{
		public static List<JudePrefabConfig> prefabs = new List<JudePrefabConfig>();

		public static List<StatusEffect> customSEs = new List<StatusEffect>();

		public static List<BlacksmithsToolsConfig> bsmithCfgs = new List<BlacksmithsToolsConfig>();

		public static Dictionary<string, Dictionary<string, string>> colorConfig = new Dictionary<string, Dictionary<string, string>>
		{
			{
				"ArmorBarbarianBronzeHelmetJD",
				new Dictionary<string, string>
				{
					{ "Color 1", "#FF892A" },
					{ "Color 2", "#FFFFFF" }
				}
			},
			{
				"ArmorBarbarianBronzeChestJD",
				new Dictionary<string, string>
				{
					{ "Color 1", "#FF892A" },
					{ "Color 2", "#FFFFFF" }
				}
			},
			{
				"ArmorBarbarianBronzeLegsJD",
				new Dictionary<string, string>
				{
					{ "Color 1", "#FF892A" },
					{ "Color 2", "#FFFFFF" }
				}
			},
			{
				"ArmorWarriorHelmet",
				new Dictionary<string, string> { { "Color 1", "#FF892A" } }
			},
			{
				"ArmorWarriorChest",
				new Dictionary<string, string> { { "Color 1", "#FF892A" } }
			},
			{
				"ArmorPlateIronHelmetJD",
				new Dictionary<string, string> { { "Color 1", "#FFFFFF" } }
			},
			{
				"ArmorPlateIronChestJD",
				new Dictionary<string, string> { { "Color 1", "#FFFFFF" } }
			},
			{
				"ArmorPlateIronLegsJD",
				new Dictionary<string, string> { { "Color 1", "#FFFFFF" } }
			},
			{
				"ArmorDragonslayerHelmet",
				new Dictionary<string, string> { { "Color 1", "#373737" } }
			},
			{
				"ArmorDragonslayerChest",
				new Dictionary<string, string> { { "Color 1", "#373737" } }
			},
			{
				"ArmorDragonslayerLegs",
				new Dictionary<string, string> { { "Color 1", "#373737" } }
			},
			{
				"ArmorWandererChest",
				new Dictionary<string, string> { { "Color 1", "#FFFFFF" } }
			},
			{
				"ArmorWandererLegs",
				new Dictionary<string, string> { { "Color 1", "#FFFFFF" } }
			},
			{
				"ArmorBlackmetalgarbHelmet",
				new Dictionary<string, string> { { "Color 1", "#264C35" } }
			},
			{
				"ArmorBlackmetalgarbChest",
				new Dictionary<string, string> { { "Color 1", "#264C35" } }
			},
			{
				"ArmorBlackmetalgarbLegs",
				new Dictionary<string, string> { { "Color 1", "#264C35" } }
			},
			{
				"ArmorSerpentHelmet",
				new Dictionary<string, string>
				{
					{ "Color 1", "#264C35" },
					{ "Color 2", "#FFFFFF" }
				}
			},
			{
				"ArmorSerpentChest",
				new Dictionary<string, string>
				{
					{ "Color 1", "#264C35" },
					{ "Color 2", "#FFFFFF" }
				}
			},
			{
				"ArmorSerpentLegs",
				new Dictionary<string, string>
				{
					{ "Color 1", "#264C35" },
					{ "Color 2", "#FFFFFF" }
				}
			},
			{
				"ArmorMistlandsHelmet",
				new Dictionary<string, string>
				{
					{ "Color 1", "#545454" },
					{ "Emission color", "#BF3000" }
				}
			},
			{
				"ArmorMistlandsChest",
				new Dictionary<string, string>
				{
					{ "Color 1", "#545454" },
					{ "Emission color", "#BF3000" }
				}
			},
			{
				"ArmorMistlandsLegs",
				new Dictionary<string, string>
				{
					{ "Color 1", "#545454" },
					{ "Emission color", "#BF3000" }
				}
			}
		};

		public static readonly List<string> allPrefabs = new List<string>
		{
			"ArmorNobleHelmet", "ArmorNobleChest", "ArmorNobleLegs", "ArmorNobleCape", "ArmorBarbarianBronzeHelmetJD", "ArmorBarbarianBronzeChestJD", "ArmorBarbarianBronzeLegsJD", "ArmorBarbarianCapeJD", "ArmorWarriorHelmet", "ArmorWarriorChest",
			"ArmorWarriorLegs", "ArmorPlateIronHelmetJD", "ArmorPlateIronChestJD", "ArmorPlateIronLegsJD", "ArmorPlateCape", "ArmorDragonslayerHelmet", "ArmorDragonslayerChest", "ArmorDragonslayerLegs", "ArmorWandererHelmet", "ArmorWandererChest",
			"ArmorWandererLegs", "ArmorWandererCape", "ArmorBlackmetalgarbHelmet", "ArmorBlackmetalgarbChest", "ArmorBlackmetalgarbLegs", "ArmorSerpentHelmet", "ArmorSerpentChest", "ArmorSerpentLegs", "ArmorSerpentCape", "ArmorMistlandsHelmet",
			"ArmorMistlandsChest", "ArmorMistlandsLegs", "BackpackSimple", "BackpackHeavy"
		};

		public static void AddItems()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			LoadPrefabsFromBundle();
			foreach (JudePrefabConfig prefab in prefabs)
			{
				if (!((Object)(object)prefab.GetPrefab() == (Object)null))
				{
					CustomItem val = new CustomItem(prefab.GetPrefab(), false);
					ItemManager.Instance.AddItem(val);
				}
			}
			ItemManager.OnItemsRegistered += UpdateOnLoad;
		}

		private static void UpdateOnLoad()
		{
			Main.ModConfig.ApplyArmorConfigs();
			Main.ModConfig.ApplyRecipeConfigs();
			Main.ModConfig.ApplySetEffects();
		}

		public static void InsertBsmithToolsCfgs()
		{
			if (!Main.bsmithAvailable)
			{
				return;
			}
			FieldInfo? field = Type.GetType("BlacksmithTools.BodypartSystem,BlacksmithTools").GetField("bodypartSettingsAsBones");
			Dictionary<string, List<int>> dictionary = (Dictionary<string, List<int>>)field.GetValue(field);
			foreach (BlacksmithsToolsConfig bsmithCfg in bsmithCfgs)
			{
				if (dictionary.ContainsKey(bsmithCfg.itemName))
				{
					dictionary[bsmithCfg.itemName] = new List<int>(bsmithCfg.bonesToHide);
				}
				else
				{
					dictionary.Add(bsmithCfg.itemName, new List<int>(bsmithCfg.bonesToHide));
				}
			}
		}

		private static void LoadPrefabsFromBundle()
		{
			AssetBundle bundle = Util.LoadBundle("judeequipment");
			prefabs.Clear();
			allPrefabs.ForEach(delegate(string _prefab)
			{
				prefabs.Add(new JudePrefabConfig
				{
					prefab = bundle.LoadAsset<GameObject>(_prefab)
				});
			});
			bundle.Unload(false);
		}
	}
	[HarmonyPatch]
	internal static class Patches
	{
		[HarmonyPatch]
		private static class HumanoidPatch
		{
			[HarmonyTranspiler]
			[HarmonyPatch(typeof(Humanoid), "HaveSetEffect")]
			private static IEnumerable<CodeInstruction> HaveSetEffectTranspiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected O, but got Unknown
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				return new CodeMatcher(instructions, (ILGenerator)null).Start().MatchStartForward((CodeMatch[])(object)new CodeMatch[2]
				{
					CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(ItemData), "m_setName"))),
					CodeMatch.op_Implicit(new CodeInstruction(OpCodes.Ldc_I4_1, (object)null))
				}).ThrowIfInvalid("Could not patch Humanoid.HaveSetEffect()!")
					.Advance(1)
					.SetInstruction(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null))
					.InstructionEnumeration();
			}
		}
	}
	public static class Util
	{
		public static readonly int[] Torso = new int[6] { 0, 1, 2, 3, 7, 26 };

		public static readonly int[] ArmUpperLeft = new int[1] { 8 };

		public static readonly int[] ArmLowerLeft = new int[1] { 9 };

		public static readonly int[] HandLeft = new int[17]
		{
			10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
			20, 21, 22, 23, 24, 25, 26
		};

		public static readonly int[] ArmUpperRight = new int[1] { 27 };

		public static readonly int[] ArmLowerRight = new int[1] { 28 };

		public static readonly int[] HandRight = new int[16]
		{
			29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
			39, 40, 41, 42, 43, 44
		};

		public static readonly int[] LegUpperLeft = new int[1] { 45 };

		public static readonly int[] LegLowerLeft = new int[1] { 46 };

		public static readonly int[] FootLeft = new int[2] { 47, 48 };

		public static readonly int[] LegUpperRight = new int[1] { 49 };

		public static readonly int[] LegLowerRight = new int[1] { 50 };

		public static readonly int[] FootRight = new int[2] { 51, 52 };

		public static readonly int[] TorsoUpperArms = Torso.Concat(ArmUpperLeft).Concat(ArmUpperRight).ToArray();

		public static readonly int[] TorsoUpperLowerArms = Torso.Concat(ArmUpperLeft).Concat(ArmLowerLeft).Concat(ArmUpperRight)
			.Concat(ArmLowerRight)
			.ToArray();

		public static readonly int[] CompleteLegs = LegUpperLeft.Concat(LegLowerLeft).Concat(FootLeft).Concat(LegUpperRight)
			.Concat(LegLowerRight)
			.Concat(FootRight)
			.ToArray();

		public static AssetBundle LoadBundle(string bundleName)
		{
			return AssetBundle.LoadFromStream(Main.assembly.GetManifestResourceStream(Main.assembly.GetName().Name + ".Resources." + bundleName));
		}

		public static bool IsModAvailable(string modName, string minVersion, bool printAllMods = false)
		{
			PluginInfo? obj = Chainloader.PluginInfos.Values.ToList().Find((PluginInfo _modName) => _modName.Metadata.Name == modName);
			return ((obj != null) ? obj.Metadata.Version : null) >= new Version(minVersion);
		}

		public static List<DamageModPair> ParseDmgModPairs(string def)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (string.IsNullOrEmpty(def))
				{
					return new List<DamageModPair>();
				}
				def = def.Trim();
				List<DamageModPair> list = new List<DamageModPair>();
				string[] array = def.Split(new char[1] { ';' });
				for (int i = 0; i < array.Length; i++)
				{
					string[] array2 = array[i].Split(new char[1] { ':' });
					DamageType type = (DamageType)Enum.Parse(typeof(DamageType), array2[0].ToString().Trim());
					DamageModifier modifier = (DamageModifier)Enum.Parse(typeof(DamageModifier), array2[1].ToString().Trim());
					list.Add(new DamageModPair
					{
						m_type = type,
						m_modifier = modifier
					});
				}
				return list;
			}
			catch (Exception ex)
			{
				Main.log.LogError((object)"An error occured when parsing damge modifiers");
				Main.log.LogError((object)ex.Message);
				return new List<DamageModPair>();
			}
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("GoldenJude_JudesEquipment", "JudesEquipment", "3.0.0")]
	public class Main : BaseUnityPlugin
	{
		public const string MODNAME = "JudesEquipment";

		public const string AUTHOR = "GoldenJude";

		public const string GUID = "GoldenJude_JudesEquipment";

		public const string VERSION = "3.0.0";

		private static string ConfigFileName = "GoldenJude_JudesEquipment.cfg";

		private static string ConfigFileFullPath;

		public static ManualLogSource log;

		internal readonly Harmony harmony;

		public static Assembly assembly;

		public const string bundleName = "judeequipment";

		public const string itemConfigName = "GoldenJude_JudesEquipment_ItemConfig.yml";

		public const string localizationconfigName = "GoldenJude_JudesEquipment_Localization.yml";

		public const string colorConfigName = "GoldenJude_JudesEquipment_Colors.yml";

		public static ConfigEntry<bool> neutralMetals;

		public static ConfigEntry<bool> smoothTextures;

		private readonly ConfigurationManagerAttributes AdminConfig = new ConfigurationManagerAttributes
		{
			IsAdminOnly = true
		};

		private readonly ConfigurationManagerAttributes ClientConfig = new ConfigurationManagerAttributes
		{
			IsAdminOnly = false
		};

		public static Shader creatureShader;

		public static bool bsmithAvailable;

		public static bool hugosCollidersAvaiable;

		public static JudeItemConfig ModConfig;

		public static CustomLocalization Localization;

		public static FileSystemWatcher fsw;

		private DateTime _lastReloadTime;

		private const long RELOAD_DELAY = 10000000L;

		private void AddConfig<T>(string key, string section, string description, bool synced, T value, ref ConfigEntry<T> configEntry)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			string extendedDescription = GetExtendedDescription(description, synced);
			configEntry = ((BaseUnityPlugin)this).Config.Bind<T>(section, key, value, new ConfigDescription(extendedDescription, (AcceptableValueBase)null, new object[1] { synced ? AdminConfig : ClientConfig }));
		}

		public string GetExtendedDescription(string description, bool synchronizedSetting)
		{
			return description + (synchronizedSetting ? " [Synced with Server]" : " [Not Synced with Server]");
		}

		public Main()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			log = ((BaseUnityPlugin)this).Logger;
			harmony = new Harmony("GoldenJude_JudesEquipment");
			assembly = Assembly.GetExecutingAssembly();
		}

		public void Start()
		{
			harmony.PatchAll(assembly);
			bsmithAvailable = Util.IsModAvailable("BlacksmithTools", "3.0.0");
			hugosCollidersAvaiable = Util.IsModAvailable("More Player Cloth Colliders", "3.0.0");
			if (bsmithAvailable)
			{
				CreateBlacksmithsTooslConfigs();
				ItemManager.InsertBsmithToolsCfgs();
			}
			AddConfig("Appearance", "Neutral metals", "Makes all metals a neutral grey", synced: true, value: false, ref neutralMetals);
			AddConfig("Appearance", "Smooth textures", "Removes pixelization filter on all textures, overrides color config", synced: true, value: false, ref smoothTextures);
			string text = AssetUtils.LoadTextFromResources("Localization.English.json", Assembly.GetExecutingAssembly());
			Localization.AddJsonFile("English", text);
			ItemManager.AddItems();
			LoadColorConfig();
			SetupWatcher();
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
		}

		private void SetupWatcher()
		{
			_lastReloadTime = DateTime.Now;
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, ConfigFileName);
			fileSystemWatcher.Changed += ReadConfigValues;
			fileSystemWatcher.Created += ReadConfigValues;
			fileSystemWatcher.Renamed += ReadConfigValues;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private void ReadConfigValues(object sender, FileSystemEventArgs e)
		{
			DateTime now = DateTime.Now;
			long num = now.Ticks - _lastReloadTime.Ticks;
			if (File.Exists(ConfigFileFullPath) && num >= 10000000)
			{
				try
				{
					Logger.LogInfo((object)"Attempting to reload configuration...");
					((BaseUnityPlugin)this).Config.Reload();
				}
				catch
				{
					Logger.LogError((object)("There was an issue loading " + ConfigFileName));
					return;
				}
				_lastReloadTime = now;
			}
		}

		public static void LoadColorConfig()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = Directory.GetFiles(Paths.ConfigPath, "GoldenJude_JudesEquipment_Colors.yml", SearchOption.AllDirectories).ToList();
			if (list.Count == 0)
			{
				File.WriteAllText(Path.Combine(Paths.ConfigPath, "GoldenJude_JudesEquipment_Colors.yml"), new SerializerBuilder().Build().Serialize((object)ItemManager.colorConfig));
				return;
			}
			new Dictionary<string, Dictionary<string, string>>();
			try
			{
				ItemManager.colorConfig = new DeserializerBuilder().Build().Deserialize<Dictionary<string, Dictionary<string, string>>>(File.ReadAllText(list[0]));
			}
			catch (Exception ex)
			{
				log.LogWarning((object)"An error occured when loading GoldenJude_JudesEquipment_Colors.yml, will use default values");
				log.LogWarning((object)ex.Message);
				log.LogWarning((object)ex.StackTrace);
			}
		}

		public static void CreateBlacksmithsTooslConfigs()
		{
			if (bsmithAvailable)
			{
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorNobleChest",
					bonesToHide = Util.TorsoUpperLowerArms
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorNobleLegs",
					bonesToHide = Util.CompleteLegs
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorBlackmetalgarbChest",
					bonesToHide = Util.TorsoUpperArms
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorBlackmetalgarbLegs",
					bonesToHide = Util.CompleteLegs
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorBarbarianBronzeLegsJD",
					bonesToHide = Util.CompleteLegs
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorWarriorLegs",
					bonesToHide = Util.CompleteLegs
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorWandererChest",
					bonesToHide = Util.TorsoUpperArms
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorWandererLegs",
					bonesToHide = Util.CompleteLegs
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorDragonslayerChest",
					bonesToHide = Util.TorsoUpperArms
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorDragonslayerLegs",
					bonesToHide = Util.CompleteLegs
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorMistlandsChest",
					bonesToHide = Util.TorsoUpperLowerArms
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorMistlandsLegs",
					bonesToHide = Util.CompleteLegs
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorSerpentChest",
					bonesToHide = Util.TorsoUpperLowerArms
				});
				ItemManager.bsmithCfgs.Add(new BlacksmithsToolsConfig
				{
					itemName = "ArmorSerpentLegs",
					bonesToHide = Util.CompleteLegs
				});
			}
		}

		static Main()
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			ConfigFileFullPath = configPath + directorySeparatorChar + ConfigFileName;
			bsmithAvailable = false;
			hugosCollidersAvaiable = false;
			ModConfig = new JudeItemConfig();
			Localization = LocalizationManager.Instance.GetLocalization();
			fsw = new FileSystemWatcher
			{
				Path = Paths.ConfigPath,
				IncludeSubdirectories = true,
				EnableRaisingEvents = true
			};
		}
	}
}
namespace JudesEquipment.Properties
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					resourceMan = new ResourceManager("JudesEquipment.Properties.Resources", typeof(Resources).Assembly);
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static byte[] judeequipment => (byte[])ResourceManager.GetObject("judeequipment", resourceCulture);

		internal Resources()
		{
		}
	}
}
namespace JudesEquipment.BlacksmithWares
{
	internal class bodyhiding
	{
		public Texture2D GetTextureMask()
		{
			Main.log.LogWarning((object)"Body hiding - GetTextureMask() not supported!");
			return null;
		}
	}
}
namespace JudesEquipment.Configuration
{
	public class BlacksmithsToolsConfig
	{
		public string itemName;

		public int[] bonesToHide;
	}
	public class JudeArmorConfig
	{
		[YamlMember(Alias = "item prefab name")]
		public string prefabName = string.Empty;

		[YamlMember(Alias = "required for set bonus")]
		public bool countsTowardsSetBonus = true;

		public int armor;

		[YamlMember(Alias = "armor per level")]
		public int armorPerLevel = 2;

		[YamlMember(Alias = "enable durability")]
		public bool enableDurability = true;

		public int baseDurability = 1000;

		[YamlMember(Alias = "durability per level")]
		public int durabilityPerLevel = 200;

		public bool repairable = true;

		[YamlMember(Alias = "destroy when broken")]
		public bool destroyBroken;

		public int weight;

		public bool teleportable = true;

		[YamlMember(Alias = "maximum upgrade level")]
		public int maxUpgradeLevel = 4;

		[YamlMember(Alias = "movement speed modifier")]
		public int movementSpeedModifier;

		[YamlMember(Alias = "damage modifiers")]
		public Dictionary<string, string> damageModifiers = new Dictionary<string, string>
		{
			{
				((object)(DamageType)1/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)2/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)4/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)8/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)16/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)32/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)64/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)128/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)256/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)512/*cast due to .constrained prefix*/).ToString(),
				"none"
			}
		};

		[YamlMember(Alias = "recipe")]
		public JudeRecipeConfig recipe = new JudeRecipeConfig();

		public void ApplyConfig()
		{
			JudePrefabConfig? judePrefabConfig = ItemManager.prefabs.Find((JudePrefabConfig judePrefabConfig2) => ((Object)judePrefabConfig2.GetPrefab()).name == prefabName);
			object obj;
			if (judePrefabConfig == null)
			{
				obj = null;
			}
			else
			{
				GameObject prefab = judePrefabConfig.GetPrefab();
				obj = ((prefab != null) ? prefab.GetComponent<ItemDrop>().m_itemData.m_shared : null);
			}
			SharedData val = (SharedData)obj;
			if (val != null)
			{
				val.m_weight = weight;
				val.m_armor = armor;
				val.m_armorPerLevel = armorPerLevel;
				val.m_damageModifiers = ParseModPairs(damageModifiers);
				val.m_maxDurability = baseDurability;
				val.m_durabilityPerLevel = durabilityPerLevel;
				val.m_destroyBroken = destroyBroken;
				val.m_canBeReparied = repairable;
				val.m_movementModifier = (float)movementSpeedModifier / 100f;
				val.m_equipDuration = 1f;
				val.m_maxQuality = maxUpgradeLevel;
				val.m_useDurability = enableDurability;
			}
		}

		public static List<DamageModPair> ParseModPairs(Dictionary<string, string> mods)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			List<DamageModPair> list = new List<DamageModPair>();
			foreach (KeyValuePair<string, string> mod in mods)
			{
				if (!(mod.Value.ToLower() == "none"))
				{
					DamageType type = (DamageType)Enum.Parse(typeof(DamageType), mod.Key, ignoreCase: true);
					DamageModifier modifier = (DamageModifier)Enum.Parse(typeof(DamageModifier), mod.Value, ignoreCase: true);
					list.Add(new DamageModPair
					{
						m_type = type,
						m_modifier = modifier
					});
				}
			}
			return list;
		}
	}
	public class JudeArmorSetConfig
	{
		[YamlMember(Alias = "set effect")]
		public SetEffect setEffect = new SetEffect();

		public Dictionary<string, JudeArmorConfig> items = new Dictionary<string, JudeArmorConfig>();

		public void ApplyArmorConfigs()
		{
			items.Values.ToList().ForEach(delegate(JudeArmorConfig piece)
			{
				piece.ApplyConfig();
			});
		}

		public void ApplyRecipeConfigs()
		{
			items.Values.ToList().ForEach(delegate(JudeArmorConfig piece)
			{
				piece.recipe.ApplyConfig(piece.prefabName);
			});
		}

		public void ApplySetConfig(string effectName)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return;
			}
			SE_Stats effect = (SE_Stats)ObjectDB.instance.m_StatusEffects.Find((StatusEffect se) => ((Object)se).name == effectName);
			bool flag = false;
			if ((Object)(object)effect == (Object)null)
			{
				effect = ScriptableObject.CreateInstance<SE_Stats>();
				((Object)effect).name = effectName;
				((StatusEffect)effect).m_icon = ObjectDB.instance.m_items.Find((GameObject iconSource) => ((Object)iconSource).name == items.Values.ToList()[0].prefabName).GetComponent<ItemDrop>().m_itemData.m_shared.m_icons[0];
				flag = true;
			}
			effect.m_healthRegenMultiplier = (float)setEffect.healthRegenModifier / 100f + 1f;
			effect.m_staminaRegenMultiplier = (float)setEffect.staminaReregenModifier / 100f + 1f;
			effect.m_addMaxCarryWeight = setEffect.carryWeightModifier;
			effect.m_mods = JudeArmorConfig.ParseModPairs(setEffect.damageModifiers);
			effect.m_skillLevel = (SkillType)Enum.Parse(typeof(SkillType), setEffect.skillModifier.skill);
			effect.m_skillLevelModifier = setEffect.skillModifier.modifier;
			effect.m_runStaminaDrainModifier = (float)setEffect.runStaminaDrainModifier / 100f;
			effect.m_jumpStaminaUseModifier = (float)setEffect.jumpStaminaDrainModifier / 100f;
			items.Values.ToList().ForEach(delegate(JudeArmorConfig piece)
			{
				if (piece.countsTowardsSetBonus)
				{
					GameObject prefab = ItemManager.prefabs.Find((JudePrefabConfig armor) => ((Object)armor.GetPrefab()).name == piece.prefabName).GetPrefab();
					ItemDrop obj = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
					obj.m_itemData.m_shared.m_setStatusEffect = (StatusEffect)(object)effect;
					obj.m_itemData.m_shared.m_setName = effectName;
					obj.m_itemData.m_shared.m_setSize = GetSetSize();
				}
			});
			if (flag)
			{
				ObjectDB.instance.m_StatusEffects.Add((StatusEffect)(object)effect);
				ItemManager.customSEs.Add((StatusEffect)(object)effect);
			}
		}

		public int GetSetSize()
		{
			int num = 0;
			foreach (JudeArmorConfig value in items.Values)
			{
				if (value.countsTowardsSetBonus)
				{
					num++;
				}
			}
			return num;
		}
	}
	public class JudeItemConfig
	{
		[YamlMember(Alias = "noble's armor")]
		public Noble noble = new Noble();

		[YamlMember(Alias = "barbarian's armor")]
		public Barbarian barbarian = new Barbarian();

		[YamlMember(Alias = "warrior's armor")]
		public Warrior warrior = new Warrior();

		[YamlMember(Alias = "plate armor")]
		public Plate plate = new Plate();

		[YamlMember(Alias = "dragonslayer's armor")]
		public Dragonslayer dragonslayer = new Dragonslayer();

		[YamlMember(Alias = "wanderer's armor")]
		public Wanderer wanderer = new Wanderer();

		[YamlMember(Alias = "nomad's armor")]
		public Nomad nomad = new Nomad();

		[YamlMember(Alias = "serpent armor")]
		public Serpent serpent = new Serpent();

		[YamlMember(Alias = "scorched armor")]
		public Scorched scorched = new Scorched();

		[YamlMember(Alias = "simple backpack")]
		public SimpleBackpack simpleBackpack = new SimpleBackpack();

		[YamlMember(Alias = "heavy backpack")]
		public HeavyBackpack heavyBackpack = new HeavyBackpack();

		[YamlIgnore]
		private List<JudeArmorSetConfig> Sets => new List<JudeArmorSetConfig>
		{
			noble, barbarian, warrior, plate, dragonslayer, wanderer, nomad, serpent, scorched, simpleBackpack,
			heavyBackpack
		};

		public void ApplyArmorConfigs()
		{
			Sets.ForEach(delegate(JudeArmorSetConfig set)
			{
				set.ApplyArmorConfigs();
			});
		}

		public void ApplyRecipeConfigs()
		{
			Sets.ForEach(delegate(JudeArmorSetConfig set)
			{
				set.ApplyRecipeConfigs();
			});
		}

		public void ApplySetEffects()
		{
			Sets.ForEach(delegate(JudeArmorSetConfig set)
			{
				set.ApplySetConfig(set.items.Values.First().prefabName);
			});
		}
	}
	public class JudePrefabConfig
	{
		public GameObject prefab;

		public bool replaceMat = true;

		public GameObject GetPrefab()
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Invalid comparison between Unknown and I4
			if ((Object)(object)prefab == (Object)null)
			{
				Main.log.LogWarning((object)"prefab null");
				return null;
			}
			prefab.layer = 12;
			ItemDrop component = prefab.GetComponent<ItemDrop>();
			SharedData shared = component.m_itemData.m_shared;
			prefab.layer = 12;
			string name = "$" + ((Object)prefab).name;
			string description = "$" + ((Object)prefab).name + "_description";
			shared.m_name = name;
			shared.m_description = description;
			if (replaceMat)
			{
				ReplaceMaterials();
			}
			if (!Main.hugosCollidersAvaiable && (int)component.m_itemData.m_shared.m_itemType != 17)
			{
				prefab.GetComponentsInChildren<Cloth>(true).ToList().ForEach(delegate(Cloth cloth)
				{
					Object.Destroy((Object)(object)cloth);
				});
			}
			return prefab;
		}

		public void ReplaceMaterials()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)prefab == (Object)null || (Object)(object)Main.creatureShader == (Object)null)
			{
				return;
			}
			List<Renderer> list = new List<Renderer>();
			list.AddRange((IEnumerable<Renderer>)(object)prefab.GetComponentsInChildren<MeshRenderer>(true));
			list.AddRange((IEnumerable<Renderer>)(object)prefab.GetComponentsInChildren<SkinnedMeshRenderer>(true));
			foreach (Renderer item in list)
			{
				List<Material> list2 = new List<Material>();
				int num = 0;
				Material[] materials = item.materials;
				foreach (Material mat in materials)
				{
					string[] source = new string[4] { "_MainTex", "_BumpMap", "_MetallicGlossMap", "_EmissionMap" };
					(new string[1])[0] = "_BumpMap";
					Material replacerMat = new Material(Main.creatureShader);
					replacerMat.SetFloat("_Cull", 0f);
					replacerMat.SetFloat("_AddRain", 1f);
					replacerMat.SetFloat("_Glossiness", 0f);
					int num2 = (((Object)(object)mat.GetTexture("_MetallicGlossMap") != (Object)null) ? 1 : 0);
					replacerMat.SetFloat("_Metallic", (float)num2);
					replacerMat.SetFloat("_MetalGloss", mat.GetFloat("_GlossMapScale"));
					replacerMat.SetFloat("_TwoSidedNormals", 1f);
					Color val = mat.GetColor("_Color");
					Color val2 = mat.GetColor("_EmissionColor");
					if (Main.neutralMetals.Value)
					{
						val = Color.grey;
						val2 = Color.black;
					}
					else if (ItemManager.colorConfig.ContainsKey(((Object)prefab).name))
					{
						string key = "Color " + (num + 1);
						if (ItemManager.colorConfig[((Object)prefab).name].ContainsKey(key))
						{
							ColorUtility.TryParseHtmlString(ItemManager.colorConfig[((Object)prefab).name][key], ref val);
						}
						if (ItemManager.colorConfig[((Object)prefab).name].ContainsKey("Emission color"))
						{
							ColorUtility.TryParseHtmlString(ItemManager.colorConfig[((Object)prefab).name]["Emission color"], ref val2);
						}
					}
					replacerMat.SetColor("_Color", Color.white);
					replacerMat.SetColor("_MetalColor", val);
					replacerMat.SetColor("_EmissionColor", val2);
					replacerMat.EnableKeyword("_ADDRAIN_ON");
					replacerMat.EnableKeyword("_TWOSIDEDNORMALS_ON");
					source.ToList().ForEach(delegate(string tex)
					{
						Texture texture = mat.GetTexture(tex);
						if ((Object)(object)texture != (Object)null && Main.smoothTextures.Value)
						{
							texture.filterMode = (FilterMode)1;
						}
						replacerMat.SetTexture(tex, texture);
					});
					list2.Add(replacerMat);
					num++;
				}
				item.materials = list2.ToArray();
			}
			replaceMat = false;
		}
	}
	public class JudeRecipeConfig
	{
		public class RequirementConfig
		{
			[YamlMember(Alias = "item")]
			public string item;

			[YamlMember(Alias = "amount")]
			public int amount;

			[YamlMember(Alias = "amount per level")]
			public int amountPerLevel;

			public Requirement GetRequirement()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				Requirement val = new Requirement();
				GameObject? obj = ObjectDB.instance.m_items.Find((GameObject _item) => ((Object)_item).name == item);
				val.m_resItem = ((obj != null) ? obj.GetComponent<ItemDrop>() : null);
				if ((Object)(object)val.m_resItem == (Object)null)
				{
					return null;
				}
				val.m_amount = amount;
				val.m_amountPerLevel = amountPerLevel;
				val.m_recover = true;
				return val;
			}
		}

		[YamlMember(Alias = "enabled")]
		public bool enabled = true;

		[YamlIgnore]
		public int amount = 1;

		[YamlMember(Alias = "station")]
		public string station = string.Empty;

		[YamlMember(Alias = "minimum station level")]
		public int minimumStationLevel = 1;

		[YamlMember(Alias = "requirements")]
		public List<RequirementConfig> requirements = new List<RequirementConfig>();

		public void ApplyConfig(string prefabName)
		{
			bool flag = false;
			string recipeName = prefabName + "_recipe";
			if ((Object)(object)ObjectDB.instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null || !enabled)
			{
				return;
			}
			Recipe val = ObjectDB.instance.m_recipes?.Find((Recipe _recipe) => ((Object)_recipe).name == recipeName);
			if ((Object)(object)val == (Object)null)
			{
				flag = true;
			}
			JudePrefabConfig? judePrefabConfig = ItemManager.prefabs.Find((JudePrefabConfig _prefab) => ((Object)_prefab.GetPrefab()).name == prefabName);
			object obj;
			if (judePrefabConfig == null)
			{
				obj = null;
			}
			else
			{
				GameObject prefab = judePrefabConfig.GetPrefab();
				obj = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
			}
			ItemDrop val2 = (ItemDrop)obj;
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			if (flag)
			{
				val = ScriptableObject.CreateInstance<Recipe>();
				((Object)val).name = recipeName;
				ObjectDB.instance.m_recipes.Add(val);
			}
			val.m_enabled = enabled;
			val.m_item = val2;
			val.m_amount = amount;
			Recipe obj2 = val;
			GameObject prefab2 = ZNetScene.instance.GetPrefab(station);
			obj2.m_craftingStation = ((prefab2 != null) ? prefab2.GetComponent<CraftingStation>() : null);
			val.m_repairStation = val.m_craftingStation;
			val.m_minStationLevel = minimumStationLevel;
			List<Requirement> resolvedRequirements = new List<Requirement>();
			requirements.ForEach(delegate(RequirementConfig reqCfg)
			{
				Requirement requirement = reqCfg.GetRequirement();
				if (requirement != null)
				{
					resolvedRequirements.Add(requirement);
				}
			});
			val.m_resources = resolvedRequirements.ToArray();
		}
	}
	public class SetEffect
	{
		[YamlMember(Alias = "health regen modifier")]
		public int healthRegenModifier;

		[YamlMember(Alias = "stamina regen modifier")]
		public int staminaReregenModifier;

		[YamlMember(Alias = "run stamina drain modifier")]
		public int runStaminaDrainModifier;

		[YamlMember(Alias = "jump stamina drain modifier")]
		public int jumpStaminaDrainModifier;

		[YamlMember(Alias = "carry weight modifier")]
		public int carryWeightModifier;

		[YamlMember(Alias = "skill modifier")]
		public SkillModifier skillModifier = new SkillModifier();

		[YamlMember(Alias = "damage modifiers")]
		public Dictionary<string, string> damageModifiers = new Dictionary<string, string>
		{
			{
				((object)(DamageType)1/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)2/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)4/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)8/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)16/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)32/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)64/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)128/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)256/*cast due to .constrained prefix*/).ToString(),
				"none"
			},
			{
				((object)(DamageType)512/*cast due to .constrained prefix*/).ToString(),
				"none"
			}
		};
	}
	public class SkillModifier
	{
		public string skill = "None";

		public int modifier;
	}
}
namespace JudesEquipment.ArmorSets
{
	public class Barbarian : JudeArmorSetConfig
	{
		public Barbarian()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			setEffect = new SetEffect
			{
				staminaReregenModifier = 25,
				skillModifier = new SkillModifier
				{
					skill = ((object)(SkillType)7/*cast due to .constrained prefix*/).ToString(),
					modifier = 25
				}
			};
			int armor = 4;
			int weight = 10;
			JudeArmorConfig value = new JudeArmorConfig
			{
				prefabName = "ArmorBarbarianBronzeHelmetJD",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Bronze",
							amount = 5,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "DeerHide",
							amount = 2,
							amountPerLevel = 0
						}
					}
				}
			};
			JudeArmorConfig value2 = new JudeArmorConfig
			{
				prefabName = "ArmorBarbarianBronzeChestJD",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Bronze",
							amount = 5,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "DeerHide",
							amount = 2,
							amountPerLevel = 0
						}
					}
				}
			};
			JudeArmorConfig value3 = new JudeArmorConfig
			{
				prefabName = "ArmorBarbarianBronzeLegsJD",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Bronze",
							amount = 5,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "DeerHide",
							amount = 2,
							amountPerLevel = 0
						}
					}
				}
			};
			JudeArmorConfig value4 = new JudeArmorConfig
			{
				prefabName = "ArmorBarbarianCapeJD",
				armor = 4,
				weight = 6,
				movementSpeedModifier = -3,
				countsTowardsSetBonus = false,
				recipe = new JudeRecipeConfig
				{
					station = "piece_workbench",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "DeerHide",
							amount = 8,
							amountPerLevel = 4
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Bronze",
							amount = 1,
							amountPerLevel = 1
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "BoneFragments",
							amount = 5,
							amountPerLevel = 3
						}
					}
				}
			};
			items.Add("helmet", value);
			items.Add("chest", value2);
			items.Add("legs", value3);
			items.Add("cape", value4);
		}
	}
	public class Dragonslayer : JudeArmorSetConfig
	{
		public Dragonslayer()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			setEffect = new SetEffect
			{
				jumpStaminaDrainModifier = -25,
				skillModifier = new SkillModifier
				{
					skill = ((object)(SkillType)100/*cast due to .constrained prefix*/).ToString(),
					modifier = 30
				}
			};
			setEffect.damageModifiers[((object)(DamageType)64/*cast due to .constrained prefix*/).ToString()] = ((object)(DamageModifier)1/*cast due to .constrained prefix*/).ToString();
			int armor = 24;
			int weight = 20;
			int movementSpeedModifier = -5;
			JudeArmorConfig value = new JudeArmorConfig
			{
				prefabName = "ArmorDragonslayerHelmet",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Silver",
							amount = 20,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "WolfPelt",
							amount = 10,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Obsidian",
							amount = 10,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "TrophyHatchling",
							amount = 2,
							amountPerLevel = 0
						}
					}
				}
			};
			JudeArmorConfig value2 = new JudeArmorConfig
			{
				prefabName = "ArmorDragonslayerChest",
				armor = armor,
				weight = weight,
				movementSpeedModifier = movementSpeedModifier,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Silver",
							amount = 20,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "WolfPelt",
							amount = 10,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Obsidian",
							amount = 10,
							amountPerLevel = 3
						}
					}
				}
			};
			JudeArmorConfig value3 = new JudeArmorConfig
			{
				prefabName = "ArmorDragonslayerLegs",
				armor = armor,
				weight = weight,
				movementSpeedModifier = movementSpeedModifier,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Silver",
							amount = 20,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "WolfPelt",
							amount = 10,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Obsidian",
							amount = 10,
							amountPerLevel = 3
						}
					}
				}
			};
			items.Add("helmet", value);
			items.Add("chest", value2);
			items.Add("legs", value3);
		}
	}
	public class HeavyBackpack : JudeArmorSetConfig
	{
		public HeavyBackpack()
		{
			setEffect = new SetEffect
			{
				carryWeightModifier = 200
			};
			JudeArmorConfig value = new JudeArmorConfig
			{
				prefabName = "BackpackHeavy",
				armor = 0,
				weight = 30,
				movementSpeedModifier = -5,
				baseDurability = 100,
				durabilityPerLevel = 100,
				recipe = new JudeRecipeConfig
				{
					station = "piece_workbench",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Wood",
							amount = 20,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "DeerHide",
							amount = 5,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "IronNails",
							amount = 10,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Iron",
							amount = 2,
							amountPerLevel = 1
						}
					}
				}
			};
			items.Add("backpack", value);
		}
	}
	public class Noble : JudeArmorSetConfig
	{
		public Noble()
		{
			setEffect = new SetEffect
			{
				staminaReregenModifier = 5,
				healthRegenModifier = 5,
				runStaminaDrainModifier = -5
			};
			int armor = 1;
			int weight = 5;
			string station = "piece_workbench";
			string item = "LeatherScraps";
			int amount = 5;
			int amountPerLevel = 1;
			string item2 = "DeerHide";
			int amount2 = 2;
			int amountPerLevel2 = 1;
			JudeArmorConfig value = new JudeArmorConfig
			{
				prefabName = "ArmorNobleHelmet",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = station,
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = item,
							amount = amount,
							amountPerLevel = amountPerLevel
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = item2,
							amount = amount2,
							amountPerLevel = amountPerLevel2
						}
					}
				}
			};
			JudeArmorConfig value2 = new JudeArmorConfig
			{
				prefabName = "ArmorNobleChest",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = station,
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = item,
							amount = amount,
							amountPerLevel = amountPerLevel
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = item2,
							amount = amount2,
							amountPerLevel = amountPerLevel2
						}
					}
				}
			};
			JudeArmorConfig value3 = new JudeArmorConfig
			{
				prefabName = "ArmorNobleLegs",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = station,
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = item,
							amount = amount,
							amountPerLevel = amountPerLevel
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = item2,
							amount = amount2,
							amountPerLevel = amountPerLevel2
						}
					}
				}
			};
			JudeArmorConfig value4 = new JudeArmorConfig
			{
				prefabName = "ArmorNobleCape",
				armor = 1,
				weight = 1,
				countsTowardsSetBonus = false,
				recipe = new JudeRecipeConfig
				{
					station = station,
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = item,
							amount = amount,
							amountPerLevel = amountPerLevel
						}
					}
				}
			};
			items.Add("helmet", value);
			items.Add("chest", value2);
			items.Add("legs", value3);
			items.Add("cape", value4);
		}
	}
	public class Nomad : JudeArmorSetConfig
	{
		public Nomad()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			setEffect = new SetEffect
			{
				runStaminaDrainModifier = -15,
				skillModifier = new SkillModifier
				{
					skill = ((object)(SkillType)102/*cast due to .constrained prefix*/).ToString(),
					modifier = 25
				}
			};
			setEffect.damageModifiers[((object)(DamageType)64/*cast due to .constrained prefix*/).ToString().ToString()] = ((object)(DamageModifier)1/*cast due to .constrained prefix*/).ToString();
			int armor = 20;
			int weight = 10;
			JudeArmorConfig value = new JudeArmorConfig
			{
				prefabName = "ArmorBlackmetalgarbHelmet",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "BlackMetal",
							amount = 15,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LoxPelt",
							amount = 10,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LinenThread",
							amount = 20,
							amountPerLevel = 5
						}
					}
				}
			};
			JudeArmorConfig value2 = new JudeArmorConfig
			{
				prefabName = "ArmorBlackmetalgarbChest",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "BlackMetal",
							amount = 15,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LoxPelt",
							amount = 10,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LinenThread",
							amount = 20,
							amountPerLevel = 5
						}
					}
				}
			};
			JudeArmorConfig value3 = new JudeArmorConfig
			{
				prefabName = "ArmorBlackmetalgarbLegs",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "BlackMetal",
							amount = 15,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LoxPelt",
							amount = 10,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LinenThread",
							amount = 20,
							amountPerLevel = 5
						}
					}
				}
			};
			items.Add("helmet", value);
			items.Add("chest", value2);
			items.Add("legs", value3);
		}
	}
	public class Plate : JudeArmorSetConfig
	{
		public Plate()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			setEffect = new SetEffect
			{
				healthRegenModifier = 10,
				skillModifier = new SkillModifier
				{
					skill = ((object)(SkillType)6/*cast due to .constrained prefix*/).ToString(),
					modifier = 20
				}
			};
			int armor = 18;
			int weight = 20;
			int movementSpeedModifier = -5;
			JudeArmorConfig value = new JudeArmorConfig
			{
				prefabName = "ArmorPlateIronHelmetJD",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Iron",
							amount = 20,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "DeerHide",
							amount = 5,
							amountPerLevel = 1
						}
					}
				}
			};
			JudeArmorConfig value2 = new JudeArmorConfig
			{
				prefabName = "ArmorPlateIronChestJD",
				armor = armor,
				weight = weight,
				movementSpeedModifier = movementSpeedModifier,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Iron",
							amount = 25,
							amountPerLevel = 8
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "DeerHide",
							amount = 5,
							amountPerLevel = 1
						}
					}
				}
			};
			JudeArmorConfig value3 = new JudeArmorConfig
			{
				prefabName = "ArmorPlateIronLegsJD",
				armor = armor,
				weight = weight,
				movementSpeedModifier = movementSpeedModifier,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Iron",
							amount = 25,
							amountPerLevel = 8
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "DeerHide",
							amount = 5,
							amountPerLevel = 1
						}
					}
				}
			};
			JudeArmorConfig value4 = new JudeArmorConfig
			{
				prefabName = "ArmorPlateCape",
				armor = 4,
				weight = 8,
				movementSpeedModifier = -3,
				countsTowardsSetBonus = false,
				recipe = new JudeRecipeConfig
				{
					station = "piece_workbench",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "TrophyBoar",
							amount = 3,
							amountPerLevel = 1
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Iron",
							amount = 2,
							amountPerLevel = 1
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LeatherScraps",
							amount = 10,
							amountPerLevel = 5
						}
					}
				}
			};
			items.Add("helmet", value);
			items.Add("chest", value2);
			items.Add("legs", value3);
			items.Add("cape", value4);
		}
	}
	public class Scorched : JudeArmorSetConfig
	{
		public Scorched()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			setEffect = new SetEffect
			{
				healthRegenModifier = 10,
				skillModifier = new SkillModifier
				{
					skill = ((object)(SkillType)1/*cast due to .constrained prefix*/).ToString(),
					modifier = 15
				}
			};
			setEffect.damageModifiers[((object)(DamageType)32/*cast due to .constrained prefix*/).ToString()] = ((object)(DamageModifier)1/*cast due to .constrained prefix*/).ToString();
			setEffect.damageModifiers[((object)(DamageType)64/*cast due to .constrained prefix*/).ToString()] = ((object)(DamageModifier)1/*cast due to .constrained prefix*/).ToString();
			int armor = 34;
			int weight = 20;
			int movementSpeedModifier = -5;
			JudeArmorConfig value = new JudeArmorConfig
			{
				prefabName = "ArmorMistlandsHelmet",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "FlametalNew",
							amount = 20,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LoxPelt",
							amount = 10,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LinenThread",
							amount = 10,
							amountPerLevel = 3
						}
					}
				}
			};
			JudeArmorConfig value2 = new JudeArmorConfig
			{
				prefabName = "ArmorMistlandsChest",
				armor = armor,
				weight = weight,
				movementSpeedModifier = movementSpeedModifier,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "FlametalNew",
							amount = 20,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LoxPelt",
							amount = 10,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LinenThread",
							amount = 10,
							amountPerLevel = 3
						}
					}
				}
			};
			JudeArmorConfig value3 = new JudeArmorConfig
			{
				prefabName = "ArmorMistlandsLegs",
				armor = armor,
				weight = weight,
				movementSpeedModifier = movementSpeedModifier,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "FlametalNew",
							amount = 20,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LoxPelt",
							amount = 10,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LinenThread",
							amount = 10,
							amountPerLevel = 3
						}
					}
				}
			};
			items.Add("helmet", value);
			items.Add("chest", value2);
			items.Add("legs", value3);
		}
	}
	public class Serpent : JudeArmorSetConfig
	{
		public Serpent()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			setEffect = new SetEffect
			{
				staminaReregenModifier = 15,
				healthRegenModifier = 15,
				skillModifier = new SkillModifier
				{
					skill = ((object)(SkillType)103/*cast due to .constrained prefix*/).ToString(),
					modifier = 30
				}
			};
			int armor = 30;
			int weight = 20;
			int movementSpeedModifier = -5;
			JudeArmorConfig value = new JudeArmorConfig
			{
				prefabName = "ArmorSerpentHelmet",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "BlackMetal",
							amount = 15,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Silver",
							amount = 10,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LoxPelt",
							amount = 10,
							amountPerLevel = 2
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "TrophySerpent",
							amount = 2,
							amountPerLevel = 0
						}
					}
				}
			};
			JudeArmorConfig value2 = new JudeArmorConfig
			{
				prefabName = "ArmorSerpentChest",
				armor = armor,
				weight = weight,
				movementSpeedModifier = movementSpeedModifier,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "BlackMetal",
							amount = 15,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Silver",
							amount = 10,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LoxPelt",
							amount = 5,
							amountPerLevel = 2
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "SerpentScale",
							amount = 5,
							amountPerLevel = 2
						}
					}
				}
			};
			JudeArmorConfig value3 = new JudeArmorConfig
			{
				prefabName = "ArmorSerpentLegs",
				armor = armor,
				weight = weight,
				movementSpeedModifier = movementSpeedModifier,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "BlackMetal",
							amount = 15,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Silver",
							amount = 10,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LoxPelt",
							amount = 5,
							amountPerLevel = 2
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "SerpentScale",
							amount = 5,
							amountPerLevel = 2
						}
					}
				}
			};
			JudeArmorConfig judeArmorConfig = new JudeArmorConfig
			{
				prefabName = "ArmorSerpentCape",
				armor = 3,
				weight = 6,
				recipe = new JudeRecipeConfig
				{
					station = "piece_workbench",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Silver",
							amount = 5,
							amountPerLevel = 1
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LinenThread",
							amount = 20,
							amountPerLevel = 5
						}
					}
				}
			};
			judeArmorConfig.damageModifiers[((object)(DamageType)64/*cast due to .constrained prefix*/).ToString()] = ((object)(DamageModifier)1/*cast due to .constrained prefix*/).ToString();
			items.Add("helmet", value);
			items.Add("chest", value2);
			items.Add("legs", value3);
			items.Add("cape", judeArmorConfig);
		}
	}
	public class SimpleBackpack : JudeArmorSetConfig
	{
		public SimpleBackpack()
		{
			setEffect = new SetEffect
			{
				carryWeightModifier = 100
			};
			JudeArmorConfig value = new JudeArmorConfig
			{
				prefabName = "BackpackSimple",
				armor = 0,
				weight = 15,
				movementSpeedModifier = -5,
				baseDurability = 10,
				durabilityPerLevel = 10,
				recipe = new JudeRecipeConfig
				{
					station = "piece_workbench",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Wood",
							amount = 20,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "DeerHide",
							amount = 5,
							amountPerLevel = 2
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LeatherScraps",
							amount = 10,
							amountPerLevel = 5
						}
					}
				}
			};
			items.Add("backpack", value);
		}
	}
	public class Wanderer : JudeArmorSetConfig
	{
		public Wanderer()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			setEffect = new SetEffect
			{
				staminaReregenModifier = 15,
				carryWeightModifier = 50,
				skillModifier = new SkillModifier
				{
					skill = ((object)(SkillType)1/*cast due to .constrained prefix*/).ToString(),
					modifier = 15
				}
			};
			int armor = 22;
			int weight = 10;
			int movementSpeedModifier = -3;
			JudeArmorConfig value = new JudeArmorConfig
			{
				prefabName = "ArmorWandererHelmet",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Flax",
							amount = 15,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Iron",
							amount = 10,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LinenThread",
							amount = 10,
							amountPerLevel = 3
						}
					}
				}
			};
			JudeArmorConfig value2 = new JudeArmorConfig
			{
				prefabName = "ArmorWandererChest",
				armor = armor,
				weight = weight,
				movementSpeedModifier = movementSpeedModifier,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Iron",
							amount = 10,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LinenThread",
							amount = 20,
							amountPerLevel = 10
						}
					}
				}
			};
			JudeArmorConfig value3 = new JudeArmorConfig
			{
				prefabName = "ArmorWandererLegs",
				armor = armor,
				weight = weight,
				movementSpeedModifier = movementSpeedModifier,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Iron",
							amount = 10,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LinenThread",
							amount = 20,
							amountPerLevel = 10
						}
					}
				}
			};
			JudeArmorConfig value4 = new JudeArmorConfig
			{
				prefabName = "ArmorWandererCape",
				armor = 2,
				weight = 5,
				countsTowardsSetBonus = false,
				recipe = new JudeRecipeConfig
				{
					station = "piece_workbench",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Flax",
							amount = 15,
							amountPerLevel = 5
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Iron",
							amount = 10,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "LinenThread",
							amount = 10,
							amountPerLevel = 3
						}
					}
				}
			};
			items.Add("helmet", value);
			items.Add("chest", value2);
			items.Add("legs", value3);
			items.Add("cape", value4);
		}
	}
	public class Warrior : JudeArmorSetConfig
	{
		public Warrior()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			setEffect = new SetEffect
			{
				healthRegenModifier = 10,
				skillModifier = new SkillModifier
				{
					skill = ((object)(SkillType)4/*cast due to .constrained prefix*/).ToString(),
					modifier = 15
				}
			};
			setEffect.damageModifiers[((object)(DamageType)2/*cast due to .constrained prefix*/).ToString()] = ((object)(DamageModifier)1/*cast due to .constrained prefix*/).ToString();
			int armor = 6;
			int weight = 15;
			int movementSpeedModifier = -5;
			JudeArmorConfig value = new JudeArmorConfig
			{
				prefabName = "ArmorWarriorHelmet",
				armor = armor,
				weight = weight,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Bronze",
							amount = 5,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "DeerHide",
							amount = 3,
							amountPerLevel = 1
						}
					}
				}
			};
			JudeArmorConfig value2 = new JudeArmorConfig
			{
				prefabName = "ArmorWarriorChest",
				armor = armor,
				weight = weight,
				movementSpeedModifier = movementSpeedModifier,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Bronze",
							amount = 5,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "DeerHide",
							amount = 3,
							amountPerLevel = 1
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Stone",
							amount = 20,
							amountPerLevel = 0
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Raspberry",
							amount = 20,
							amountPerLevel = 0
						}
					}
				}
			};
			JudeArmorConfig value3 = new JudeArmorConfig
			{
				prefabName = "ArmorWarriorLegs",
				armor = armor,
				weight = weight,
				movementSpeedModifier = movementSpeedModifier,
				recipe = new JudeRecipeConfig
				{
					station = "forge",
					requirements = new List<JudeRecipeConfig.RequirementConfig>
					{
						new JudeRecipeConfig.RequirementConfig
						{
							item = "Bronze",
							amount = 5,
							amountPerLevel = 3
						},
						new JudeRecipeConfig.RequirementConfig
						{
							item = "DeerHide",
							amount = 3,
							amountPerLevel = 1
						}
					}
				}
			};
			items.Add("helmet", value);
			items.Add("chest", value2);
			items.Add("legs", value3);
		}
	}
}