using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ValheimHTDArmory")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyProduct("ValheimHTDArmory")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("3f0e3454-5e9d-41aa-a53d-c3f412189855")]
[assembly: AssemblyFileVersion("8.3.7")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("8.3.7.0")]
[module: UnverifiableCode]
public class UpgradeMods : MonoBehaviour
{
	private bool persistPastLevel2 = true;

	private bool persistPastLevel3 = true;

	private void Start()
	{
		((Component)((Component)this).transform.Find("levelmods/lvl1")).gameObject.SetActive(false);
		((Component)((Component)this).transform.Find("levelmods/lvl2")).gameObject.SetActive(false);
		((Component)((Component)this).transform.Find("levelmods/lvl3")).gameObject.SetActive(false);
	}

	private void Update()
	{
	}

	private void TryApplyMods(ItemDrop itemInstance)
	{
		ItemData itemData = itemInstance.m_itemData;
		if ((itemData.m_quality == 2 && !persistPastLevel2) || (itemData.m_quality >= 2 && persistPastLevel2))
		{
			((Component)((Component)this).transform.Find("levelmods/lvl2")).gameObject.SetActive(true);
		}
		if ((itemData.m_quality == 3 && !persistPastLevel3) || (itemData.m_quality >= 3 && persistPastLevel3))
		{
			((Component)((Component)this).transform.Find("levelmods/lvl3")).gameObject.SetActive(true);
		}
		if (itemData.m_quality >= 4)
		{
			((Component)((Component)this).transform.Find("levelmods/lvl4")).gameObject.SetActive(true);
		}
	}
}
namespace ValheimHTDArmory;

public class CustomConfig
{
	[Serializable]
	public class ConfigArmorData
	{
		public string ItemPrefab;

		public bool Enabled = true;

		public int MaxQuality = -1;

		public float Weight = -1f;

		public bool UseDurability = true;

		public float MaxDurability = -1f;

		public float DurabilityPerLevel = -1f;

		public float MovementModifier = -1f;

		public float Armor = -1f;

		public float ArmorPerLevel = -1f;

		public void WriteConfigDataToArmor(ref ItemDrop item)
		{
			SharedData shared = item.m_itemData.m_shared;
			shared.m_maxQuality = ((MaxQuality == -1) ? shared.m_maxQuality : MaxQuality);
			shared.m_weight = ((Weight == -1f) ? shared.m_weight : Weight);
			shared.m_useDurability = UseDurability;
			item.m_itemData.m_durability = ((MaxDurability == -1f) ? shared.m_maxDurability : MaxDurability);
			shared.m_maxDurability = ((MaxDurability == -1f) ? shared.m_maxDurability : MaxDurability);
			shared.m_durabilityPerLevel = ((DurabilityPerLevel == -1f) ? shared.m_durabilityPerLevel : DurabilityPerLevel);
			shared.m_movementModifier = ((MovementModifier == -1f) ? shared.m_movementModifier : MovementModifier);
			shared.m_armor = ((Armor == -1f) ? shared.m_armor : Armor);
			shared.m_armorPerLevel = ((ArmorPerLevel == -1f) ? shared.m_armorPerLevel : ArmorPerLevel);
		}

		public void ReadConfigDataFromArmor(GameObject go)
		{
			SharedData shared = go.GetComponent<ItemDrop>().m_itemData.m_shared;
			ItemPrefab = ((Object)go).name;
			UseDurability = shared.m_useDurability;
			MaxQuality = shared.m_maxQuality;
			Weight = shared.m_weight;
			MaxDurability = shared.m_maxDurability;
			DurabilityPerLevel = shared.m_durabilityPerLevel;
			MovementModifier = shared.m_movementModifier;
			Armor = shared.m_armor;
			ArmorPerLevel = shared.m_armorPerLevel;
		}
	}

	[Serializable]
	public class ConfigItemData
	{
		public string ItemPrefab;

		public bool Enabled = true;

		public int MaxQuality = -1;

		public float Weight = -1f;

		public bool UseDurability = true;

		public float MaxDurability = -1f;

		public float DurabilityPerLevel = -1f;

		public float MovementModifier = -1f;

		public float BlockAmount = -1f;

		public float BlockAmountPerLevel = -1f;

		public float DeflectionForce = -1f;

		public float DeflectionForcePerLevel = -1f;

		public float ParryBonus = -1f;

		public float Knockback_Power = -1f;

		public float Backstab_Bonus = -1f;

		public float DamageBlunt = -1f;

		public float DamageSlash = -1f;

		public float DamagePierce = -1f;

		public float DamageChop = -1f;

		public float DamagePickaxe = -1f;

		public float DamageFire = -1f;

		public float DamageFrost = -1f;

		public float DamageLightning = -1f;

		public float DamagePoison = -1f;

		public float DamageSpirit = -1f;

		public float DamageBluntPerLevel = -1f;

		public float DamageSlashPerLevel = -1f;

		public float DamagePiercePerLevel = -1f;

		public float DamageChopPerLevel = -1f;

		public float DamagePickaxePerLevel = -1f;

		public float DamageFirePerLevel = -1f;

		public float DamageFrostPerLevel = -1f;

		public float DamageLightningPerLevel = -1f;

		public float DamagePoisonPerLevel = -1f;

		public float DamageSpiritPerLevel = -1f;

		public void WriteConfigDataToItem(ref ItemDrop item)
		{
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			SharedData shared = item.m_itemData.m_shared;
			shared.m_maxQuality = ((MaxQuality == -1) ? shared.m_maxQuality : MaxQuality);
			shared.m_weight = ((Weight == -1f) ? shared.m_weight : Weight);
			shared.m_useDurability = UseDurability;
			item.m_itemData.m_durability = ((MaxDurability == -1f) ? shared.m_maxDurability : MaxDurability);
			shared.m_maxDurability = ((MaxDurability == -1f) ? shared.m_maxDurability : MaxDurability);
			shared.m_durabilityPerLevel = ((DurabilityPerLevel == -1f) ? shared.m_durabilityPerLevel : DurabilityPerLevel);
			shared.m_movementModifier = ((!Enabled) ? 0f : ((MovementModifier == -1f) ? shared.m_movementModifier : MovementModifier));
			shared.m_blockPower = ((BlockAmount == -1f) ? shared.m_blockPower : BlockAmount);
			shared.m_blockPowerPerLevel = ((BlockAmountPerLevel == -1f) ? shared.m_blockPowerPerLevel : BlockAmountPerLevel);
			shared.m_deflectionForce = ((DeflectionForce == -1f) ? shared.m_deflectionForce : DeflectionForce);
			shared.m_deflectionForcePerLevel = ((DeflectionForcePerLevel == -1f) ? shared.m_deflectionForcePerLevel : DeflectionForcePerLevel);
			shared.m_timedBlockBonus = ((ParryBonus == -1f) ? shared.m_timedBlockBonus : ParryBonus);
			shared.m_attackForce = ((Knockback_Power == -1f) ? shared.m_attackForce : Knockback_Power);
			shared.m_backstabBonus = ((Backstab_Bonus == -1f) ? shared.m_backstabBonus : Backstab_Bonus);
			shared.m_damages = (Enabled ? SetDamageValues() : disabledDamages);
			shared.m_damagesPerLevel = (Enabled ? SetDamagePerLevelValues() : disabledDamages);
		}

		public void ReadConfigDataFromItem(GameObject go)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			SharedData shared = go.GetComponent<ItemDrop>().m_itemData.m_shared;
			ItemPrefab = ((Object)go).name;
			UseDurability = shared.m_useDurability;
			MaxQuality = shared.m_maxQuality;
			Weight = shared.m_weight;
			MaxDurability = shared.m_maxDurability;
			DurabilityPerLevel = shared.m_durabilityPerLevel;
			MovementModifier = shared.m_movementModifier;
			BlockAmount = shared.m_blockPower;
			BlockAmountPerLevel = shared.m_blockPowerPerLevel;
			DeflectionForce = shared.m_deflectionForce;
			DeflectionForcePerLevel = shared.m_deflectionForcePerLevel;
			ParryBonus = shared.m_timedBlockBonus;
			Knockback_Power = shared.m_attackForce;
			Backstab_Bonus = shared.m_backstabBonus;
			GetDamageValues(shared.m_damages);
			GetDamagePerLevelValues(shared.m_damagesPerLevel);
		}

		private DamageTypes SetDamageValues()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			return new DamageTypes
			{
				m_blunt = DamageBlunt,
				m_slash = DamageSlash,
				m_pierce = DamagePierce,
				m_chop = DamageChop,
				m_pickaxe = DamagePickaxe,
				m_fire = DamageFire,
				m_frost = DamageFrost,
				m_lightning = DamageLightning,
				m_poison = DamagePoison,
				m_spirit = DamageSpirit
			};
		}

		private DamageTypes SetDamagePerLevelValues()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			return new DamageTypes
			{
				m_blunt = DamageBluntPerLevel,
				m_slash = DamageSlashPerLevel,
				m_pierce = DamagePiercePerLevel,
				m_chop = DamageChopPerLevel,
				m_pickaxe = DamagePickaxePerLevel,
				m_fire = DamageFirePerLevel,
				m_frost = DamageFrostPerLevel,
				m_lightning = DamageLightningPerLevel,
				m_poison = DamagePoisonPerLevel,
				m_spirit = DamageSpiritPerLevel
			};
		}

		private void GetDamageValues(DamageTypes damageList)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			DamageBlunt = damageList.m_blunt;
			DamageSlash = damageList.m_slash;
			DamagePierce = damageList.m_pierce;
			DamageChop = damageList.m_chop;
			DamagePickaxe = damageList.m_pickaxe;
			DamageFire = damageList.m_fire;
			DamageFrost = damageList.m_frost;
			DamageLightning = damageList.m_lightning;
			DamagePoison = damageList.m_poison;
			DamageSpirit = damageList.m_spirit;
		}

		private void GetDamagePerLevelValues(DamageTypes damageList)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			DamageBluntPerLevel = damageList.m_blunt;
			DamageSlashPerLevel = damageList.m_slash;
			DamagePiercePerLevel = damageList.m_pierce;
			DamageChopPerLevel = damageList.m_chop;
			DamagePickaxePerLevel = damageList.m_pickaxe;
			DamageFirePerLevel = damageList.m_fire;
			DamageFrostPerLevel = damageList.m_frost;
			DamageLightningPerLevel = damageList.m_lightning;
			DamagePoisonPerLevel = damageList.m_poison;
			DamageSpiritPerLevel = damageList.m_spirit;
		}
	}

	[Serializable]
	public class ConfigResource
	{
		public string ItemPrefab;

		public int CraftingCost = 0;

		public int UpgradePerLevelCost = 0;
	}

	[Serializable]
	public class ConfigRecipeData
	{
		public string ItemPrefab;

		public bool Enabled = true;

		public string CraftingStation = "forge";

		public string RepairStation = "forge";

		public int MinimumStationLevel = 1;

		public ConfigResource[] CraftingRequirementsArray;

		public string CraftingRequirements;

		public RecipeHelper LoadConfigedRecipeHelper(GameObject itemToCraft)
		{
			RecipeHelper recipeHelper = new RecipeHelper(itemToCraft, CraftingStation, MinimumStationLevel, 1);
			recipeHelper.recipeEnabled = Enabled;
			ConfigResource[] craftingRequirementsArray = CraftingRequirementsArray;
			foreach (ConfigResource configResource in craftingRequirementsArray)
			{
				recipeHelper.AddResource(configResource.ItemPrefab, configResource.CraftingCost, configResource.UpgradePerLevelCost);
			}
			return recipeHelper;
		}

		public void ReadConfigFromRecipeHelper(RecipeHelper rh)
		{
			ItemPrefab = rh.GetPrefabName();
			CraftingStation = rh.GetCraftingStation();
			RepairStation = rh.GetRepairStation();
			MinimumStationLevel = rh.GetRecipeInstance().m_minStationLevel;
			ResourceElement[] resourceElements = rh.GetResourceElements();
			List<ConfigResource> list = new List<ConfigResource>();
			ResourceElement[] array = resourceElements;
			foreach (ResourceElement resourceElement in array)
			{
				ConfigResource configResource = new ConfigResource();
				configResource.ItemPrefab = resourceElement.prefabItemName;
				configResource.CraftingCost = resourceElement.amount;
				configResource.UpgradePerLevelCost = resourceElement.amountPerLevel;
				list.Add(configResource);
			}
			CraftingRequirementsArray = list.ToArray();
		}
	}

	public List<ConfigItemData> itemConfigs = new List<ConfigItemData>();

	public List<ConfigRecipeData> recipeConfigs = new List<ConfigRecipeData>();

	public List<ConfigArmorData> armorConfigs = new List<ConfigArmorData>();

	private Dictionary<string, ConfigItemData> itemConfigsToApply = new Dictionary<string, ConfigItemData>();

	private Dictionary<string, ConfigRecipeData> recipeConfigsToApply = new Dictionary<string, ConfigRecipeData>();

	private Dictionary<string, ConfigArmorData> armorConfigsToApply = new Dictionary<string, ConfigArmorData>();

	private bool itemConfigFound = false;

	private bool recipeConfigFound = false;

	private bool armorConfigFound = false;

	private string itemConfigSuffix = "_itemdata";

	private string recipeConfigSuffix = "_recipeData";

	private string armorConfigSuffix = "_armorData";

	private static DamageTypes disabledDamages = default(DamageTypes);

	private void ItemConfigsChanged()
	{
		itemConfigs.Clear();
		itemConfigsToApply.Clear();
		Plugin.RebuildItems();
	}

	private void RecipeConfigChanged()
	{
		recipeConfigs.Clear();
		recipeConfigsToApply.Clear();
		Plugin.RebuildRecipes();
	}

	private void ArmorConfigChanged()
	{
		armorConfigs.Clear();
		armorConfigsToApply.Clear();
	}

	public void AddItemDataAsConfigRecord(GameObject go)
	{
		ConfigItemData configItemData = new ConfigItemData();
		configItemData.ReadConfigDataFromItem(go);
		itemConfigs.RemoveAll((ConfigItemData ic) => ic.ItemPrefab == ((Object)go).name);
		itemConfigs.Add(configItemData);
	}

	public void ApplyItemDataFromConfigRecord(ref GameObject go)
	{
		if (itemConfigsToApply.Count > 0 && itemConfigsToApply.ContainsKey(((Object)go).name))
		{
			ItemDrop item = go.GetComponent<ItemDrop>();
			itemConfigsToApply[((Object)go).name].WriteConfigDataToItem(ref item);
			itemConfigsToApply.Remove(((Object)go).name);
		}
	}

	public void AddRecipeAsConfigRecord(RecipeHelper rh)
	{
		ConfigRecipeData configRecipeData = new ConfigRecipeData();
		ConfigRecipeData configRecipeData2 = recipeConfigs.Where((ConfigRecipeData rc) => rc.ItemPrefab == rh.GetPrefabName()).FirstOrDefault();
		if (configRecipeData2 != null)
		{
			configRecipeData.Enabled = configRecipeData2.Enabled;
		}
		configRecipeData.ReadConfigFromRecipeHelper(rh);
		recipeConfigs.RemoveAll((ConfigRecipeData rc) => rc.ItemPrefab == rh.GetPrefabName());
		recipeConfigs.Add(configRecipeData);
	}

	public RecipeHelper ApplyRecipeHelperFromConfigRecord(GameObject go)
	{
		if (recipeConfigsToApply.Count > 0 && recipeConfigsToApply.ContainsKey(((Object)go).name))
		{
			RecipeHelper result = recipeConfigsToApply[((Object)go).name].LoadConfigedRecipeHelper(go);
			recipeConfigsToApply.Remove(((Object)go).name);
			return result;
		}
		return null;
	}

	public void AddArmorDataAsConfigRecord(GameObject go)
	{
		ConfigArmorData configArmorData = new ConfigArmorData();
		configArmorData.ReadConfigDataFromArmor(go);
		armorConfigs.RemoveAll((ConfigArmorData ic) => ic.ItemPrefab == ((Object)go).name);
		armorConfigs.Add(configArmorData);
	}

	public void ApplyArmorDataFromConfigRecord(ref GameObject go)
	{
		if (armorConfigsToApply.Count > 0 && armorConfigsToApply.ContainsKey(((Object)go).name))
		{
			ItemDrop item = go.GetComponent<ItemDrop>();
			armorConfigsToApply[((Object)go).name].WriteConfigDataToArmor(ref item);
			armorConfigsToApply.Remove(((Object)go).name);
		}
	}

	public IEnumerable<ConfigItemData> DeserializeItemDataConfig(string data)
	{
		if (data.Trim().Length <= 0)
		{
			yield break;
		}
		data = data.Replace("\t", string.Empty).Replace("\r", string.Empty).Replace("\n", string.Empty);
		string[] splitData = data.Split(new char[1] { '@' });
		if (splitData.Length != 0)
		{
			string[] array = splitData;
			foreach (string itemData in array)
			{
				yield return JsonUtility.FromJson<ConfigItemData>(itemData);
			}
		}
	}

	public IEnumerable<ConfigRecipeData> DeserializeRecipeDataConfig(string data)
	{
		data = data.Replace("\t", string.Empty).Replace("\r", string.Empty).Replace("\n", string.Empty);
		if (data.Trim().Length <= 0)
		{
			yield break;
		}
		string[] splitData = data.Split(new char[1] { '@' });
		if (splitData.Length == 0)
		{
			yield break;
		}
		for (int i = 0; i < splitData.Length; i++)
		{
			string frontHalf = splitData[i].Substring(0, splitData[i].IndexOf("\"CraftingRequirements\":"));
			string backHalf = splitData[i].Substring(splitData[i].IndexOf("\"CraftingRequirements\":"));
			frontHalf += "\"CraftingRequirements\": \"\"}";
			backHalf = backHalf.Substring(backHalf.IndexOf(":") + 1);
			backHalf = backHalf.Remove(backHalf.Length - 1);
			ConfigRecipeData itemData = JsonUtility.FromJson<ConfigRecipeData>(frontHalf);
			string[] splitResourceData = backHalf.Split(new char[1] { '#' });
			if (splitResourceData.Length != 0)
			{
				List<ConfigResource> res = new List<ConfigResource>();
				for (int j = 0; j < splitResourceData.Length; j++)
				{
					res.Add(JsonUtility.FromJson<ConfigResource>(splitResourceData[j]));
				}
				itemData.CraftingRequirementsArray = res.ToArray();
			}
			yield return itemData;
		}
	}

	public IEnumerable<ConfigArmorData> DeserializeArmorDataConfig(string data)
	{
		if (data.Trim().Length <= 0)
		{
			yield break;
		}
		data = data.Replace("\t", string.Empty).Replace("\r", string.Empty).Replace("\n", string.Empty);
		string[] splitData = data.Split(new char[1] { '@' });
		if (splitData.Length != 0)
		{
			string[] array = splitData;
			foreach (string itemData in array)
			{
				yield return JsonUtility.FromJson<ConfigArmorData>(itemData);
			}
		}
	}

	public void LoadInitialConfigs(string bepinexConfigPath)
	{
	}

	public string SerializeItemDataConfig()
	{
		StringBuilder stringBuilder = new StringBuilder();
		foreach (ConfigItemData itemConfig in itemConfigs)
		{
			if (stringBuilder.Length > 0)
			{
				stringBuilder.Append("\r\n@\r\n");
			}
			stringBuilder.Append(JsonUtility.ToJson((object)itemConfig, true));
		}
		return stringBuilder.ToString();
	}

	public string SerializeRecipeDataConfig()
	{
		StringBuilder stringBuilder = new StringBuilder();
		foreach (ConfigRecipeData recipeConfig in recipeConfigs)
		{
			if (stringBuilder.Length > 0)
			{
				stringBuilder.Append("\r\n@\r\n");
			}
			if (recipeConfig.CraftingRequirementsArray.Length != 0)
			{
				bool flag = false;
				ConfigResource[] craftingRequirementsArray = recipeConfig.CraftingRequirementsArray;
				foreach (ConfigResource configResource in craftingRequirementsArray)
				{
					if (flag)
					{
						recipeConfig.CraftingRequirements += "#";
					}
					recipeConfig.CraftingRequirements += JsonUtility.ToJson((object)configResource);
					flag = true;
				}
			}
			string text = JsonUtility.ToJson((object)recipeConfig, true);
			text = text.Replace("\"{", "\r\n\t{\r\n\t\t");
			text = text.Replace("}\"", "\r\n\t}");
			text = text.Replace(",\\\"", ",\r\n\t\t\"");
			text = text.Replace("\\\"", "\"");
			text = text.Replace("}#{", "\r\n\t}\r\n\t#\r\n\t{\r\n\t\t");
			stringBuilder.Append(text);
		}
		return stringBuilder.ToString();
	}

	public string SerializeArmorDataConfig()
	{
		StringBuilder stringBuilder = new StringBuilder();
		foreach (ConfigArmorData armorConfig in armorConfigs)
		{
			if (stringBuilder.Length > 0)
			{
				stringBuilder.Append("\r\n@\r\n");
			}
			stringBuilder.Append(JsonUtility.ToJson((object)armorConfig, true));
		}
		return stringBuilder.ToString();
	}

	public void WriteConfigs(string bepinexConfigPath)
	{
		try
		{
			if (itemConfigs.Count > 0)
			{
				using StreamWriter streamWriter = new StreamWriter(bepinexConfigPath + itemConfigSuffix + ".cfg");
				streamWriter.Write(SerializeItemDataConfig());
			}
		}
		catch (IOException ex)
		{
			Plugin.Log.LogError((object)("An IO Exception was thrown. [" + itemConfigSuffix + "]"));
			Plugin.Log.LogError((object)ex.Message);
			Plugin.Log.LogError((object)ex.StackTrace);
		}
		try
		{
			if (recipeConfigs.Count > 0)
			{
				using StreamWriter streamWriter2 = new StreamWriter(bepinexConfigPath + recipeConfigSuffix + ".cfg");
				streamWriter2.Write(SerializeRecipeDataConfig());
			}
		}
		catch (IOException ex2)
		{
			Plugin.Log.LogError((object)("An IO Exception was thrown. [" + recipeConfigSuffix + "]"));
			Plugin.Log.LogError((object)ex2.Message);
			Plugin.Log.LogError((object)ex2.StackTrace);
		}
		try
		{
			if (armorConfigs.Count > 0)
			{
				using (StreamWriter streamWriter3 = new StreamWriter(bepinexConfigPath + armorConfigSuffix + ".cfg"))
				{
					streamWriter3.Write(SerializeArmorDataConfig());
					return;
				}
			}
		}
		catch (IOException ex3)
		{
			Plugin.Log.LogError((object)("An IO Exception was thrown. [" + armorConfigSuffix + "]"));
			Plugin.Log.LogError((object)ex3.Message);
			Plugin.Log.LogError((object)ex3.StackTrace);
		}
	}
}
public static class CustomConfigParser
{
	public static string SerializeObject<T>(T obj)
	{
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.AppendLine("Object:" + obj.GetType().Name);
		FieldInfo[] fields = obj.GetType().GetFields();
		FieldInfo[] array = fields;
		foreach (FieldInfo fieldInfo in array)
		{
			stringBuilder.AppendLine($"\t{fieldInfo.Name}: {fieldInfo.GetValue(obj)}");
		}
		return stringBuilder.ToString();
	}
}
public class SE_Stats_ProgressiveSet : SE_Stats
{
	private Player player;

	private float bonusModifier = 0f;

	private float timer;

	private float baseTime = 2f;

	private static Dictionary<string, float> allProgressiveSEs = new Dictionary<string, float>();

	private void CrunchNumbers()
	{
		if ((Object)(object)player != (Object)null)
		{
			bonusModifier = 0f;
			ItemData rightItem = ((Humanoid)player).m_rightItem;
			object obj;
			if (rightItem == null)
			{
				obj = null;
			}
			else
			{
				StatusEffect setStatusEffect = rightItem.m_shared.m_setStatusEffect;
				obj = ((setStatusEffect != null) ? ((Object)setStatusEffect).name : null);
			}
			if ((string?)obj == ((Object)this).name)
			{
				DoMathStuff(ref bonusModifier, ((Humanoid)player).m_rightItem);
			}
			ItemData leftItem = ((Humanoid)player).m_leftItem;
			object obj2;
			if (leftItem == null)
			{
				obj2 = null;
			}
			else
			{
				StatusEffect setStatusEffect2 = leftItem.m_shared.m_setStatusEffect;
				obj2 = ((setStatusEffect2 != null) ? ((Object)setStatusEffect2).name : null);
			}
			if ((string?)obj2 == ((Object)this).name)
			{
				DoMathStuff(ref bonusModifier, ((Humanoid)player).m_leftItem);
			}
			ItemData helmetItem = ((Humanoid)player).m_helmetItem;
			object obj3;
			if (helmetItem == null)
			{
				obj3 = null;
			}
			else
			{
				StatusEffect setStatusEffect3 = helmetItem.m_shared.m_setStatusEffect;
				obj3 = ((setStatusEffect3 != null) ? ((Object)setStatusEffect3).name : null);
			}
			if ((string?)obj3 == ((Object)this).name)
			{
				DoMathStuff(ref bonusModifier, ((Humanoid)player).m_helmetItem);
			}
			ItemData chestItem = ((Humanoid)player).m_chestItem;
			object obj4;
			if (chestItem == null)
			{
				obj4 = null;
			}
			else
			{
				StatusEffect setStatusEffect4 = chestItem.m_shared.m_setStatusEffect;
				obj4 = ((setStatusEffect4 != null) ? ((Object)setStatusEffect4).name : null);
			}
			if ((string?)obj4 == ((Object)this).name)
			{
				DoMathStuff(ref bonusModifier, ((Humanoid)player).m_chestItem);
			}
			ItemData legItem = ((Humanoid)player).m_legItem;
			object obj5;
			if (legItem == null)
			{
				obj5 = null;
			}
			else
			{
				StatusEffect setStatusEffect5 = legItem.m_shared.m_setStatusEffect;
				obj5 = ((setStatusEffect5 != null) ? ((Object)setStatusEffect5).name : null);
			}
			if ((string?)obj5 == ((Object)this).name)
			{
				DoMathStuff(ref bonusModifier, ((Humanoid)player).m_legItem);
			}
			ItemData shoulderItem = ((Humanoid)player).m_shoulderItem;
			object obj6;
			if (shoulderItem == null)
			{
				obj6 = null;
			}
			else
			{
				StatusEffect setStatusEffect6 = shoulderItem.m_shared.m_setStatusEffect;
				obj6 = ((setStatusEffect6 != null) ? ((Object)setStatusEffect6).name : null);
			}
			if ((string?)obj6 == ((Object)this).name)
			{
				DoMathStuff(ref bonusModifier, ((Humanoid)player).m_shoulderItem);
			}
			ItemData utilityItem = ((Humanoid)player).m_utilityItem;
			object obj7;
			if (utilityItem == null)
			{
				obj7 = null;
			}
			else
			{
				StatusEffect setStatusEffect7 = utilityItem.m_shared.m_setStatusEffect;
				obj7 = ((setStatusEffect7 != null) ? ((Object)setStatusEffect7).name : null);
			}
			if ((string?)obj7 == ((Object)this).name)
			{
				DoMathStuff(ref bonusModifier, ((Humanoid)player).m_utilityItem);
			}
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				allProgressiveSEs[((Object)this).name] = bonusModifier;
			}
		}
	}

	private void DoMathStuff(ref float mainValue, ItemData id)
	{
		mainValue += (float)(id.m_quality - 1) / (float)id.m_shared.m_maxQuality / (float)id.m_shared.m_setSize;
	}

	public override void Setup(Character character)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Expected O, but got Unknown
		((SE_Stats)this).Setup(character);
		if (character is Player)
		{
			ZNetView component = ((Component)character).gameObject.GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null)
			{
				player = (Player)character;
				CrunchNumbers();
			}
		}
	}

	public override void UpdateStatusEffect(float dt)
	{
		((SE_Stats)this).UpdateStatusEffect(dt);
		if (timer > 0f)
		{
			timer -= dt;
			return;
		}
		timer = baseTime;
		CrunchNumbers();
	}

	public override void ModifyAttack(SkillType skill, ref HitData hitData)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Invalid comparison between Unknown and I4
		if (skill == base.m_modifyAttackSkill || (int)base.m_modifyAttackSkill == 999)
		{
			float num = (base.m_damageModifier - 1f) * (1f + bonusModifier);
			((DamageTypes)(ref hitData.m_damage)).Modify(1f + num);
		}
	}

	public override string GetTooltipString()
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Invalid comparison between Unknown and I4
		if (base.m_damageModifier != 1f && (int)base.m_modifyAttackSkill > 0)
		{
			float num = (allProgressiveSEs.ContainsKey(((Object)this).name) ? allProgressiveSEs[((Object)this).name] : 0f);
			float num2 = (base.m_damageModifier - 1f) * (1f + num);
			StringBuilder stringBuilder = new StringBuilder(256);
			stringBuilder.Append(((SE_Stats)this).GetTooltipString());
			stringBuilder.AppendFormat("$inventory_damage: <color=orange>{0}%</color>\n", (num2 * 100f).ToString("+0;-0"));
			return stringBuilder.ToString();
		}
		return ((SE_Stats)this).GetTooltipString();
	}

	public override void Stop()
	{
		((StatusEffect)this).Stop();
		if ((Object)(object)player == (Object)(object)Player.m_localPlayer && allProgressiveSEs.ContainsKey(((Object)this).name))
		{
			allProgressiveSEs.Remove(((Object)this).name);
		}
	}
}
internal class AudioManager
{
	public enum AudioType
	{
		ZSFX,
		AudioSource
	}

	private class PendingAudioTask
	{
		public GameObject myPrefab;

		private List<AudioTask> targets = new List<AudioTask>();
	}

	private class AudioTask
	{
		private string myNode;

		private bool copyTargetToMe = false;

		private AudioType type;

		private List<AudioTarget> targets = new List<AudioTarget>();

		public void ApplyTask(GameObject go)
		{
			if (targets.Count <= 0)
			{
				return;
			}
			Transform val = RecursiveSearchFunctions.ChildNodeFinderDepthFirst(go.transform, myNode);
			List<AudioClip> list = new List<AudioClip>();
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			foreach (AudioTarget target in targets)
			{
				switch (type)
				{
				case AudioType.ZSFX:
				{
					ZSFX component = ((Component)val).GetComponent<ZSFX>();
					if (!((Object)(object)component != (Object)null) || !((Object)(object)val != (Object)null))
					{
						break;
					}
					ZSFX component2 = ((Component)val).GetComponent<ZSFX>();
					if ((Object)(object)component2 != (Object)null && target.targetIndex == -1)
					{
						AudioClip[] audioClips = component2.m_audioClips;
						foreach (AudioClip item in audioClips)
						{
							list.Add(item);
						}
					}
					break;
				}
				}
			}
		}
	}

	private class AudioTarget
	{
		public string targetPrefab;

		public string targetNode;

		public int targetIndex = -1;
	}

	private List<PendingAudioTask> pendingAudioTasks = new List<PendingAudioTask>();
}
internal class BiomePlacer : MonoBehaviour
{
	private void Awake()
	{
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_013e: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//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)
		//IL_016f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_0178: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: Unknown result type (might be due to invalid IL or missing references)
		//IL_0187: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: Unknown result type (might be due to invalid IL or missing references)
		//IL_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
		Terrain[] componentsInChildren = ((Component)this).GetComponentsInChildren<Terrain>(true);
		if (componentsInChildren == null || componentsInChildren.Length == 0)
		{
			return;
		}
		Terrain[] array = componentsInChildren;
		foreach (Terrain val in array)
		{
			TerrainData val2 = Object.Instantiate<TerrainData>(val.terrainData);
			Terrain val3 = Object.Instantiate<Terrain>(val);
			val2.treeInstances = (TreeInstance[])(object)new TreeInstance[0];
			val2.treePrototypes = (TreePrototype[])(object)new TreePrototype[0];
			val3.terrainData = val2;
			((Component)val3).gameObject.SetActive(true);
			TerrainCollider component = ((Component)((Component)val3).transform).GetComponent<TerrainCollider>();
			if ((Object)(object)component != (Object)null)
			{
				component.terrainData = val2;
			}
			TreeInstance[] treeInstances = val.terrainData.treeInstances;
			TreePrototype[] treePrototypes = val.terrainData.treePrototypes;
			if (treeInstances.Length != 0)
			{
				TreeInstance[] array2 = treeInstances;
				foreach (TreeInstance val4 in array2)
				{
					Vector3 val5 = new Vector3(val4.position.x * val.terrainData.size.x, val4.position.y * val.terrainData.size.y, val4.position.z * val.terrainData.size.z) + ((Component)val).transform.position;
					Quaternion val6 = Quaternion.Euler(0f, Random.Range(0f, 360f), 0f);
					GameObject val7 = Object.Instantiate<GameObject>(treePrototypes[val4.prototypeIndex].prefab, val5, val6);
					val7.transform.localScale = new Vector3(val4.widthScale, val4.heightScale, val4.widthScale);
				}
			}
		}
		Object.DestroyImmediate((Object)(object)((Component)this).gameObject);
	}
}
public static class MaterialScraper
{
	private class MaterialTarget
	{
		private int stringIdHash = 0;

		public string targetPrefabName;

		public string targetMaterialChild;

		public int GetIdHash()
		{
			return stringIdHash;
		}

		public MaterialTarget(string stringId, string targetPrefab, string childName)
		{
			stringIdHash = StringExtensionMethods.GetStableHashCode(stringId);
			targetPrefabName = targetPrefab;
			targetMaterialChild = childName;
		}

		public bool IsTargetPrefab(string prefabName)
		{
			return targetPrefabName == prefabName;
		}
	}

	private static List<MaterialTarget> targets = new List<MaterialTarget>();

	public static string boarTexture = "boarskintexture";

	public static string boarHTDTexture = "boarskintexturehtd";

	public static string boarHTDTextureTS = "boarskintexturehtdtwosided";

	public static string boarTusk = "boartusk";

	public static void Init()
	{
		targets.Add(new MaterialTarget(boarTexture, "Boar", "Poly Art Boar"));
		targets.Add(new MaterialTarget(boarTusk, "Boar", "Fangs 004"));
	}

	public static void ScrapeParticleMaterials(GameObject go)
	{
		if (go.transform.childCount <= 0)
		{
			return;
		}
		for (int i = 0; i < go.transform.childCount; i++)
		{
			Transform child = go.transform.GetChild(i);
			ParticleSystemRenderer[] array = ((child != null) ? ((Component)child).GetComponentsInChildren<ParticleSystemRenderer>(true) : null);
			if (array == null || array.Length == 0)
			{
				continue;
			}
			ParticleSystemRenderer[] array2 = array;
			foreach (ParticleSystemRenderer val in array2)
			{
				if (((Renderer)val).sharedMaterials != null)
				{
					Material[] sharedMaterials = ((Renderer)val).sharedMaterials;
					foreach (Material val2 in sharedMaterials)
					{
						if ((Object)(object)val2 != (Object)null)
						{
							MyReferences.SetStoredMaterial(((Object)val2).name, val2);
							MyReferences.SetStoredShader(((Object)val2.shader).name, val2.shader);
						}
					}
				}
				if ((Object)(object)val.trailMaterial != (Object)null)
				{
					MyReferences.SetStoredMaterial(((Object)val.trailMaterial).name, val.trailMaterial);
					MyReferences.SetStoredShader(((Object)val.trailMaterial.shader).name, val.trailMaterial.shader);
				}
			}
		}
	}

	public static void ScrapeTargetMaterials(GameObject go)
	{
		if (targets.Count <= 0)
		{
			return;
		}
		foreach (MaterialTarget target in targets)
		{
			if (target.IsTargetPrefab(((Object)go).name))
			{
				Transform val = RecursiveSearchFunctions.ChildNodeFinderDepthFirst(go.transform, ref target.targetMaterialChild);
				if ((Object)(object)val != (Object)null)
				{
					Renderer component = ((Component)val).GetComponent<Renderer>();
					MyReferences.SetStoredMaterial(target.GetIdHash(), component.sharedMaterial);
				}
			}
		}
	}

	public static void ScrapRendererMaterials(GameObject go)
	{
		Renderer[] componentsInChildren = go.GetComponentsInChildren<Renderer>(true);
		if (componentsInChildren == null || componentsInChildren.Length == 0)
		{
			return;
		}
		Renderer[] array = componentsInChildren;
		foreach (Renderer val in array)
		{
			if (val.sharedMaterials == null)
			{
				continue;
			}
			Material[] sharedMaterials = val.sharedMaterials;
			foreach (Material val2 in sharedMaterials)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					MyReferences.SetStoredMaterial(((Object)val2).name, val2);
					MyReferences.SetStoredShader(((Object)val2.shader).name, val2.shader);
				}
			}
		}
	}

	public static void ScrapeItemRelatedMaterials(GameObject go)
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Invalid comparison between Unknown and I4
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Invalid comparison between Unknown and I4
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Invalid comparison between Unknown and I4
		ItemDrop component = go.GetComponent<ItemDrop>();
		if (!((Object)(object)component != (Object)null))
		{
			return;
		}
		ParticleSystemRenderer component2 = go.GetComponent<ParticleSystemRenderer>();
		if ((Object)(object)component2 != (Object)null)
		{
			MyReferences.SetStoredMaterial("item_particle", ((Renderer)component2).sharedMaterial);
		}
		SharedData shared = component.m_itemData.m_shared;
		if ((int)shared.m_itemType == 3 || (int)shared.m_itemType == 14 || (int)shared.m_itemType == 4)
		{
			if (!MyReferences.listOfMaterials.ContainsKey(StringExtensionMethods.GetStableHashCode("club_trail")))
			{
				Transform val = RecursiveSearchFunctions.ChildNodeFinderBreadthFirst(go.transform, "attach");
				if ((Object)(object)val != (Object)null)
				{
					val = RecursiveSearchFunctions.ChildNodeFinderBreadthFirst(val, "equiped");
					if ((Object)(object)val != (Object)null)
					{
						Transform val2 = RecursiveSearchFunctions.ChildNodeFinderDepthFirst(val, "trail");
						if ((Object)(object)val2 != (Object)null)
						{
							MeleeWeaponTrail component3 = ((Component)val2).gameObject.GetComponent<MeleeWeaponTrail>();
							if ((Object)(object)component3 != (Object)null)
							{
								MyReferences.SetStoredMaterial("club_trail", component3._material);
							}
						}
					}
				}
			}
			MyReferences.TryExtractEffectsFromItemDropShared(shared);
		}
		ScrapePieceMaterials(shared);
	}

	public static void ScrapePieceMaterials(SharedData shared)
	{
		if (shared == null || !((Object)(object)shared.m_buildPieces != (Object)null) || shared.m_buildPieces.m_pieces == null)
		{
			return;
		}
		List<GameObject> pieces = shared.m_buildPieces.m_pieces;
		if (pieces == null)
		{
			return;
		}
		foreach (GameObject item in pieces)
		{
			if (!((Object)(object)item == (Object)null) && ((Object)item).name != null)
			{
				Incinerator component = item.GetComponent<Incinerator>();
				if ((Object)(object)component != (Object)null && (Object)(object)component.m_lightingAOEs != (Object)null)
				{
					ScrapeParticleMaterials(component.m_lightingAOEs);
				}
				MyReferences.SetStoredPiecePrefab(((Object)item).name, item);
				StationExtension component2 = item.GetComponent<StationExtension>();
				if ((Object)(object)component2 != (Object)null && (Object)(object)component2.m_connectionPrefab != (Object)null)
				{
					MyReferences.SetStoredEffectPrefab(((Object)component2.m_connectionPrefab).name, component2.m_connectionPrefab);
				}
				CraftingStation component3 = item.GetComponent<CraftingStation>();
				if ((Object)(object)component3 != (Object)null && !MyReferences.listOfCraftingStations.ContainsKey(StringExtensionMethods.GetStableHashCode(((Object)item).name)))
				{
					MyReferences.listOfCraftingStations.Add(StringExtensionMethods.GetStableHashCode(((Object)item).name), component3);
				}
				CookingStation component4 = item.GetComponent<CookingStation>();
				if ((Object)(object)component4 != (Object)null && !MyReferences.listOfCookingStations.ContainsKey(StringExtensionMethods.GetStableHashCode(((Object)item).name)))
				{
					MyReferences.listOfCookingStations.Add(StringExtensionMethods.GetStableHashCode(((Object)item).name), component4);
				}
				Piece component5 = item.GetComponent<Piece>();
				if ((Object)(object)component5 != (Object)null)
				{
					ExtractEffectsFromPiece(component5.m_placeEffect);
				}
				WearNTear component6 = item.GetComponent<WearNTear>();
				if ((Object)(object)component6 != (Object)null)
				{
					ExtractEffectsFromPiece(component6.m_destroyedEffect);
					ExtractEffectsFromPiece(component6.m_hitEffect);
					ExtractEffectsFromPiece(component6.m_switchEffect);
				}
			}
		}
	}

	private static void ExtractEffectsFromPiece(EffectList el)
	{
		if (el.m_effectPrefabs == null || el.m_effectPrefabs.Length == 0)
		{
			return;
		}
		EffectData[] effectPrefabs = el.m_effectPrefabs;
		foreach (EffectData val in effectPrefabs)
		{
			if ((Object)(object)val.m_prefab != (Object)null)
			{
				MyReferences.SetStoredEffectPrefab(((Object)val.m_prefab).name, val.m_prefab);
			}
		}
	}

	private static void ExtractEffectsFromPiece(EffectList el, string listName)
	{
		try
		{
			if (el.m_effectPrefabs == null || el.m_effectPrefabs.Length == 0)
			{
				return;
			}
			EffectData[] effectPrefabs = el.m_effectPrefabs;
			foreach (EffectData val in effectPrefabs)
			{
				if ((Object)(object)val.m_prefab != (Object)null)
				{
					MyReferences.SetStoredEffectPrefab(((Object)val.m_prefab).name, val.m_prefab);
				}
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogError((object)("Error trying to access piece data in list " + listName));
			Plugin.Log.LogError((object)ex.Message);
			Plugin.Log.LogError((object)ex.StackTrace);
		}
	}
}
public static class MeshScraper
{
	private class MeshTarget
	{
		private int stringIdHash = 0;

		public string targetPrefabName;

		public string targetMeshChild;

		public int GetIdHash()
		{
			return stringIdHash;
		}

		public MeshTarget(string stringId, string targetPrefab, string childName)
		{
			stringIdHash = StringExtensionMethods.GetStableHashCode(stringId.ToLower());
			targetPrefabName = targetPrefab;
			targetMeshChild = childName;
		}

		public bool IsTargetPrefab(string prefabName)
		{
			return targetPrefabName == prefabName;
		}
	}

	public static string surtCoreMeshName = "surtcore";

	public static string standMeshName = "standmesh";

	public static string clothesGroundMesh = "clothesground";

	public static string stakeWallMesh = "wallstake";

	public static string woodMesh = "wood";

	private static List<MeshTarget> targets = new List<MeshTarget>();

	public static void Init()
	{
		targets.Add(new MeshTarget(surtCoreMeshName, "SurtlingCore", "core"));
		targets.Add(new MeshTarget(standMeshName, "wood_wall_roof_top", "top"));
		targets.Add(new MeshTarget(clothesGroundMesh, "ArmorRagsChest", "log"));
		targets.Add(new MeshTarget(stakeWallMesh, "stake_wall", "Stake"));
		targets.Add(new MeshTarget(woodMesh, "Wood", "log (1)"));
	}

	public static void CollectMeshes(GameObject go)
	{
		if (targets.Count <= 0)
		{
			return;
		}
		foreach (MeshTarget target in targets)
		{
			if (!target.IsTargetPrefab(((Object)go).name))
			{
				continue;
			}
			GameObject gameObject = ((Component)RecursiveSearchFunctions.ChildNodeFinderDepthFirst(go.transform, target.targetMeshChild)).gameObject;
			if (!((Object)(object)gameObject != (Object)null))
			{
				continue;
			}
			MeshFilter component = gameObject.GetComponent<MeshFilter>();
			if ((Object)(object)component != (Object)null)
			{
				MyReferences.listOfMeshes[target.GetIdHash()] = component.sharedMesh;
				continue;
			}
			SkinnedMeshRenderer component2 = gameObject.GetComponent<SkinnedMeshRenderer>();
			if ((Object)(object)component2 != (Object)null)
			{
				MyReferences.listOfMeshes[target.GetIdHash()] = component2.sharedMesh;
			}
		}
	}
}
public class PrefabFixer
{
	public class NodeData
	{
		public class MaterialTask
		{
			private string materialNameOverride;

			private string materialName;

			private string shaderName;

			private bool useCurrentMaterial = false;

			private bool fixShaderOnly = false;

			private bool mainColorChange = false;

			private Color mainTextureColor;

			private bool emissionColorChange = false;

			private bool emissionColorIsVector = false;

			private Color emissionColor;

			private bool metalColorChange = false;

			private bool metalColorIsVector = false;

			private Color metalColor;

			private int myMaterialIndex = 0;

			private bool metalGlossChange = false;

			private float metalGloss = 0f;

			private bool setTwoSided = false;

			private bool setTwoSidedNormals = false;

			private bool addRain = false;

			public MaterialTask(string materialName)
			{
				this.materialName = materialName;
			}

			public MaterialTask(string materialNameOverride, string materialName)
			{
				this.materialNameOverride = materialNameOverride;
				this.materialName = materialName;
			}

			public MaterialTask UseCurrentMaterial()
			{
				useCurrentMaterial = true;
				return this;
			}

			public MaterialTask SetShader(string shader)
			{
				shaderName = shader;
				return this;
			}

			public MaterialTask SetMainColor(Color col)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				mainTextureColor = col;
				mainColorChange = true;
				return this;
			}

			public MaterialTask SetEmissionColor(Color col, bool isVector = false)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				emissionColor = col;
				emissionColorChange = true;
				emissionColorIsVector = isVector;
				return this;
			}

			public MaterialTask SetMetalColor(Color col, bool isVector = false)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Unknown result type (might be due to invalid IL or missing references)
				metalColor = col;
				metalColorChange = true;
				metalColorIsVector = isVector;
				return this;
			}

			public MaterialTask SetMetalGloss(float value)
			{
				metalGloss = value;
				metalGlossChange = true;
				return this;
			}

			public MaterialTask SetMaterialIndex(int index)
			{
				myMaterialIndex = index;
				return this;
			}

			public MaterialTask FixShaderOnly()
			{
				fixShaderOnly = true;
				return this;
			}

			private void ApplyColor(ref Material mat, string field, Color col, bool isVector)
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: 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_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				if (isVector)
				{
					mat.SetVector(field, new Vector4(col.r, col.g, col.b, col.a));
				}
				else
				{
					mat.SetColor(field, col);
				}
			}

			public MaterialTask SetTwoSided(bool normals = false)
			{
				setTwoSided = true;
				setTwoSidedNormals = normals;
				return this;
			}

			public MaterialTask AddRain()
			{
				addRain = true;
				return this;
			}

			private void ApplyTwoSided(ref Material mat)
			{
				if (setTwoSided)
				{
					mat.SetFloat("_Cull", 0f);
				}
				if (setTwoSidedNormals)
				{
					mat.SetFloat("_TwoSidedNormals", 1f);
				}
			}

			public void TryApplyTask(Transform child)
			{
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0222: Unknown result type (might be due to invalid IL or missing references)
				//IL_0229: Expected O, but got Unknown
				//IL_0281: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
				bool flag = false;
				Material val = null;
				if (shaderName != null && fixShaderOnly)
				{
					Renderer component = ((Component)child).GetComponent<Renderer>();
					if (!((Object)(object)component == (Object)null) || !((Object)(object)component.sharedMaterial == (Object)null))
					{
						val = component.sharedMaterial;
						Shader storedShader = MyReferences.GetStoredShader(shaderName);
						if ((Object)(object)storedShader != (Object)null)
						{
							val.shader = storedShader;
						}
						if (mainColorChange)
						{
							val.SetColor("_Color", mainTextureColor);
						}
						if (emissionColorChange)
						{
							ApplyColor(ref val, "_EmissionColor", emissionColor, emissionColorIsVector);
						}
						if (metalColorChange)
						{
							ApplyColor(ref val, "_MetalColor", metalColor, metalColorIsVector);
							val.SetFloat("_Metallic", 1f);
							val.SetFloat("_UseGlossmap", 1f);
						}
						if (metalGlossChange)
						{
							val.SetFloat("_MetalGloss", metalGloss);
						}
						ApplyTwoSided(ref val);
						if (addRain)
						{
							val.SetFloat("_AddRain", 1f);
						}
						component.sharedMaterial = val;
					}
					return;
				}
				if (materialNameOverride != null)
				{
					val = MyReferences.GetStoredMaterial(materialNameOverride);
					if ((Object)(object)val != (Object)null)
					{
						flag = true;
					}
				}
				if ((Object)(object)val == (Object)null && materialName != null && !useCurrentMaterial)
				{
					val = MyReferences.GetStoredMaterial(materialName);
				}
				Renderer component2 = ((Component)child).GetComponent<Renderer>();
				if ((Object)(object)component2 != (Object)null && (Object)(object)val == (Object)null && useCurrentMaterial)
				{
					val = component2.sharedMaterials[myMaterialIndex];
				}
				else if ((Object)(object)val == (Object)null)
				{
					return;
				}
				if (!flag && materialNameOverride != null && !fixShaderOnly)
				{
					Material mat = new Material(val);
					((Object)mat).name = materialNameOverride;
					if (shaderName != null)
					{
						Shader storedShader2 = MyReferences.GetStoredShader(shaderName);
						if ((Object)(object)storedShader2 != (Object)null)
						{
							mat.shader = storedShader2;
						}
					}
					if (mainColorChange)
					{
						mat.SetColor("_Color", mainTextureColor);
					}
					if (emissionColorChange)
					{
						ApplyColor(ref mat, "_EmissionColor", emissionColor, emissionColorIsVector);
					}
					if (metalColorChange)
					{
						ApplyColor(ref mat, "_MetalColor", metalColor, metalColorIsVector);
						mat.SetFloat("_Metallic", 1f);
						mat.SetFloat("_UseGlossmap", 1f);
					}
					if (metalGlossChange)
					{
						mat.SetFloat("_MetalGloss", metalGloss);
					}
					ApplyTwoSided(ref mat);
					if (addRain)
					{
						mat.SetFloat("_AddRain", 1f);
					}
					MyReferences.SetNewStoredMaterial(materialNameOverride, mat);
					val = mat;
				}
				if (useCurrentMaterial && materialName != null)
				{
					Material storedMaterial = MyReferences.GetStoredMaterial(materialName);
					if ((Object)(object)storedMaterial != (Object)null)
					{
						val.SetTexture("_MainTex", storedMaterial.GetTexture("_MainTex"));
						val.SetTexture("_MetallicGlossMap", storedMaterial.GetTexture("_MetallicGlossMap"));
						val.SetTexture("_BumpMap", storedMaterial.GetTexture("_BumpMap"));
						if (shaderName != null)
						{
							Shader storedShader3 = MyReferences.GetStoredShader(shaderName);
							if ((Object)(object)storedShader3 != (Object)null)
							{
								val.shader = storedShader3;
							}
						}
					}
				}
				if ((Object)(object)component2 != (Object)null)
				{
					Material[] sharedMaterials = component2.sharedMaterials;
					if (sharedMaterials.Length != 0 && myMaterialIndex < sharedMaterials.Length)
					{
						sharedMaterials[myMaterialIndex] = val;
					}
					component2.sharedMaterials = sharedMaterials;
				}
			}
		}

		public class ParticleTask
		{
			private string materialNameOverride;

			private string materialName;

			private string shaderName;

			private bool setTrailMat = false;

			public ParticleTask(string materialName)
			{
				this.materialName = materialName;
			}

			public ParticleTask(string materialNameOverride, string materialName)
			{
				this.materialNameOverride = materialNameOverride;
				this.materialName = materialName;
			}

			public void SetShader(string shader)
			{
				shaderName = shader;
			}

			public void SetTrail()
			{
				setTrailMat = true;
			}

			public void TryApplyTask(Transform child)
			{
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Expected O, but got Unknown
				bool flag = false;
				Material val = null;
				if (materialNameOverride != null)
				{
					val = MyReferences.GetStoredMaterial(materialNameOverride);
					flag = true;
				}
				else if (materialName != null)
				{
					val = MyReferences.GetStoredMaterial(materialName);
				}
				if (!((Object)(object)val != (Object)null))
				{
					return;
				}
				if (shaderName != null)
				{
					Shader storedShader = MyReferences.GetStoredShader(shaderName);
					if ((Object)(object)storedShader != (Object)null)
					{
						val.shader = storedShader;
					}
				}
				if (!flag && materialNameOverride != null)
				{
					Material val2 = new Material(val);
					((Object)val2).name = materialNameOverride;
					MyReferences.SetNewStoredMaterial(materialNameOverride.GetHashCode(), val2);
					val = val2;
				}
				ParticleSystemRenderer component = ((Component)child).GetComponent<ParticleSystemRenderer>();
				if ((Object)(object)component != (Object)null)
				{
					if (setTrailMat)
					{
						component.trailMaterial = val;
					}
					else
					{
						((Renderer)component).sharedMaterial = val;
					}
				}
			}
		}

		public class MeshTask
		{
			private string meshName;

			private bool scaleChanged = false;

			private Vector3 scale = Vector3.one;

			public MeshTask(string meshName)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				this.meshName = meshName;
			}

			public MeshTask(string meshName, Vector3 scale)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				this.meshName = meshName;
				this.scale = scale;
				scaleChanged = true;
			}

			public void TryApplyTask(Transform child)
			{
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				int stableHashCode = StringExtensionMethods.GetStableHashCode(meshName);
				Mesh val = null;
				if (MyReferences.listOfMeshes.ContainsKey(stableHashCode))
				{
					val = MyReferences.listOfMeshes[stableHashCode];
				}
				if (!((Object)(object)val != (Object)null))
				{
					return;
				}
				MeshFilter component = ((Component)child).GetComponent<MeshFilter>();
				if ((Object)(object)component != (Object)null)
				{
					component.sharedMesh = val;
				}
				else
				{
					SkinnedMeshRenderer component2 = ((Component)child).GetComponent<SkinnedMeshRenderer>();
					if ((Object)(object)component2 != (Object)null)
					{
						component2.sharedMesh = val;
					}
				}
				if (scaleChanged)
				{
					child.localScale = scale;
				}
			}
		}

		private List<Transform> GameObjectChildren = new List<Transform>();

		public int numberOfInstances = 1;

		public string targetChildName;

		private MaterialTask currentMaterialTask;

		private ParticleTask currentParticleTask;

		private MeshTask currentMeshTask;

		private List<MaterialTask> materialTasks = new List<MaterialTask>();

		private List<ParticleTask> particleTasks = new List<ParticleTask>();

		private List<MeshTask> meshTasks = new List<MeshTask>();

		public NodeData(string prefabChild, int instanceCount)
		{
			targetChildName = prefabChild;
			numberOfInstances = instanceCount;
		}

		public void TryFix(GameObject go)
		{
			RecursiveSearchFunctions.ChildNodesFinderDepthFirst(go.transform, ref targetChildName, ref numberOfInstances, ref GameObjectChildren);
			if (GameObjectChildren.Count == 0)
			{
				return;
			}
			if (currentMaterialTask != null)
			{
				materialTasks.Add(currentMaterialTask);
			}
			if (currentParticleTask != null)
			{
				particleTasks.Add(currentParticleTask);
			}
			if (currentMeshTask != null)
			{
				meshTasks.Add(currentMeshTask);
			}
			foreach (Transform gameObjectChild in GameObjectChildren)
			{
				if (materialTasks.Count > 0)
				{
					foreach (MaterialTask materialTask in materialTasks)
					{
						materialTask.TryApplyTask(gameObjectChild);
					}
				}
				if (particleTasks.Count > 0)
				{
					foreach (ParticleTask particleTask in particleTasks)
					{
						particleTask.TryApplyTask(gameObjectChild);
					}
				}
				if (meshTasks.Count <= 0)
				{
					continue;
				}
				foreach (MeshTask meshTask in meshTasks)
				{
					meshTask.TryApplyTask(gameObjectChild);
				}
			}
		}

		public MaterialTask AddMaterialTask(string materialName, bool useCurrentMaterial = false)
		{
			if (currentMaterialTask != null)
			{
				materialTasks.Add(currentMaterialTask);
			}
			currentMaterialTask = new MaterialTask(materialName);
			if (useCurrentMaterial)
			{
				currentMaterialTask.UseCurrentMaterial();
			}
			return currentMaterialTask;
		}

		public MaterialTask AddMaterialTask(string materialNameOverride, string materialName, bool useCurrentMaterial = false)
		{
			if (currentMaterialTask != null)
			{
				materialTasks.Add(currentMaterialTask);
			}
			currentMaterialTask = new MaterialTask(materialNameOverride, materialName);
			if (useCurrentMaterial)
			{
				currentMaterialTask.UseCurrentMaterial();
			}
			return currentMaterialTask;
		}

		public MaterialTask SetMaterialTaskMainColor(Color col)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (currentMaterialTask != null)
			{
				currentMaterialTask.SetMainColor(col);
			}
			return currentMaterialTask;
		}

		public MaterialTask SetMaterialTaskEmissionColor(Color col)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (currentMaterialTask != null)
			{
				currentMaterialTask.SetEmissionColor(col);
			}
			return currentMaterialTask;
		}

		public MaterialTask SetMaterialTaskMetalColor(Color col)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (currentMaterialTask != null)
			{
				currentMaterialTask.SetMetalColor(col);
			}
			return currentMaterialTask;
		}

		public MaterialTask SetMaterialTaskShader(string shader)
		{
			if (currentMaterialTask != null)
			{
				currentMaterialTask.SetShader(shader);
			}
			return currentMaterialTask;
		}

		public ParticleTask AddParticleTask(string materialName, bool setTrail = false)
		{
			if (currentParticleTask != null)
			{
				particleTasks.Add(currentParticleTask);
			}
			currentParticleTask = new ParticleTask(materialName);
			if (setTrail)
			{
				currentParticleTask.SetTrail();
			}
			return currentParticleTask;
		}

		public ParticleTask AddParticleTask(string materialNameOverride, string materialName, bool setTrail = false)
		{
			if (currentParticleTask != null)
			{
				particleTasks.Add(currentParticleTask);
			}
			currentParticleTask = new ParticleTask(materialNameOverride, materialName);
			if (setTrail)
			{
				currentParticleTask.SetTrail();
			}
			return currentParticleTask;
		}

		public ParticleTask SetParticleTaskShader(string shader)
		{
			if (currentParticleTask != null)
			{
				currentParticleTask.SetShader(shader);
			}
			return currentParticleTask;
		}

		public NodeData AddMeshTask(string meshName)
		{
			if (currentMeshTask != null)
			{
				meshTasks.Add(currentMeshTask);
			}
			currentMeshTask = new MeshTask(meshName);
			return this;
		}

		public NodeData AddMeshTask(string meshName, Vector3 scale)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (currentMeshTask != null)
			{
				meshTasks.Add(currentMeshTask);
			}
			currentMeshTask = new MeshTask(meshName, scale);
			return this;
		}
	}

	private NodeData currentNode;

	private List<NodeData> nodeData = new List<NodeData>();

	public NodeData Current()
	{
		return currentNode;
	}

	public NodeData New(string childName, int instanceCount = 1)
	{
		if (currentNode != null)
		{
			nodeData.Add(currentNode);
		}
		currentNode = new NodeData(childName, instanceCount);
		return currentNode;
	}

	public void Run(ref GameObject go)
	{
		if (currentNode != null)
		{
			nodeData.Add(currentNode);
			currentNode = null;
		}
		foreach (NodeData nodeDatum in nodeData)
		{
			nodeDatum.TryFix(go);
		}
	}
}
internal class CharacterAnimEventPatch
{
}
public class CookingRecipe
{
	public string fromPrefabName;

	public ItemDrop fromItemDrop;

	public string toPrefabName;

	public ItemDrop toItemDrop;

	public float cookingTime;

	public string cookingStationName;

	public CookingRecipe(string fromPrefabName, string toPrefabName, float cookingTime, string cookingStationName)
	{
		this.fromPrefabName = fromPrefabName;
		this.toPrefabName = toPrefabName;
		this.cookingTime = cookingTime;
		this.cookingStationName = cookingStationName;
	}

	public CookingRecipe(ItemDrop fromItemDrop, ItemDrop toItemDrop, float cookingTime, string cookingStationName)
	{
		this.fromItemDrop = fromItemDrop;
		this.toItemDrop = toItemDrop;
		this.cookingTime = cookingTime;
		this.cookingStationName = cookingStationName;
	}

	public ItemDrop GetFromItemDrop()
	{
		if ((Object)(object)fromItemDrop != (Object)null)
		{
			return fromItemDrop;
		}
		CustomItem? customItem = Plugin.myCustomItems.Where((CustomItem mil) => ((Object)mil.gameObject).name == fromPrefabName).FirstOrDefault();
		ItemDrop val = ((customItem != null) ? customItem.gameObject.GetComponent<ItemDrop>() : null);
		if ((Object)(object)val == (Object)null)
		{
			return MyReferences.listOfAllGameObjects[StringExtensionMethods.GetStableHashCode(fromPrefabName)].GetComponent<ItemDrop>();
		}
		return val;
	}

	public ItemDrop GetToItemDrop()
	{
		if ((Object)(object)toItemDrop != (Object)null)
		{
			return toItemDrop;
		}
		CustomItem? customItem = Plugin.myCustomItems.Where((CustomItem mil) => ((Object)mil.gameObject).name == toPrefabName).FirstOrDefault();
		ItemDrop val = ((customItem != null) ? customItem.gameObject.GetComponent<ItemDrop>() : null);
		if ((Object)(object)val == (Object)null)
		{
			return MyReferences.listOfAllGameObjects[StringExtensionMethods.GetStableHashCode(toPrefabName)].GetComponent<ItemDrop>();
		}
		return val;
	}
}
public class CustomPiece
{
	public enum EffectListEnum
	{
		PLACEMENT,
		DESTORYED,
		HIT,
		SWITCH
	}

	public GameObject myPiece;

	private bool lookUpToolPrefab = false;

	private string buildToolPrefabName;

	private ItemDrop buildToolID;

	public string craftingStationName;

	public List<string> placeEffectNames = new List<string>();

	public List<string> destoryedEffectNames = new List<string>();

	public List<string> hitEffectNames = new List<string>();

	public List<string> switchEffectNames = new List<string>();

	private List<ResourceElement> craftingResources = new List<ResourceElement>();

	public CustomPiece SetBuildTool(string buildToolPrefabName)
	{
		this.buildToolPrefabName = buildToolPrefabName;
		lookUpToolPrefab = true;
		return this;
	}

	public CustomPiece SetBuildTool(ItemDrop buildToolID)
	{
		this.buildToolID = buildToolID;
		return this;
	}

	public CustomPiece AddEffect(EffectListEnum list, string effectName)
	{
		switch (list)
		{
		case EffectListEnum.PLACEMENT:
			placeEffectNames.Add(effectName);
			break;
		case EffectListEnum.DESTORYED:
			destoryedEffectNames.Add(effectName);
			break;
		case EffectListEnum.HIT:
			hitEffectNames.Add(effectName);
			break;
		case EffectListEnum.SWITCH:
			switchEffectNames.Add(effectName);
			break;
		}
		return this;
	}

	public CustomPiece AddEffect(EffectListEnum list, string[] effectNames)
	{
		switch (list)
		{
		case EffectListEnum.PLACEMENT:
			foreach (string item4 in effectNames)
			{
				placeEffectNames.Add(item4);
			}
			break;
		case EffectListEnum.DESTORYED:
			foreach (string item2 in effectNames)
			{
				destoryedEffectNames.Add(item2);
			}
			break;
		case EffectListEnum.HIT:
			foreach (string item3 in effectNames)
			{
				hitEffectNames.Add(item3);
			}
			break;
		case EffectListEnum.SWITCH:
			foreach (string item in effectNames)
			{
				switchEffectNames.Add(item);
			}
			break;
		}
		return this;
	}

	public CustomPiece AddResourceRequirement(string prefabName, int amount, int amountPerLevel, bool recover = true)
	{
		craftingResources.Add(new ResourceElement(prefabName, amount, amountPerLevel, recover));
		return this;
	}

	public void AddPiece()
	{
		GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(buildToolPrefabName);
		if (!((Object)(object)itemPrefab != (Object)null))
		{
			return;
		}
		ItemDrop component = itemPrefab.GetComponent<ItemDrop>();
		if (!((Object)(object)component != (Object)null))
		{
			return;
		}
		SharedData shared = component.m_itemData.m_shared;
		if ((Object)(object)shared.m_buildPieces != (Object)null)
		{
			shared.m_buildPieces.m_pieces.RemoveAll((GameObject bp) => ((Object)bp).name == ((Object)myPiece).name);
			shared.m_buildPieces.m_pieces.Add(myPiece);
		}
	}

	public void UpdateRequirements()
	{
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Expected O, but got Unknown
		if (craftingResources.Count <= 0)
		{
			return;
		}
		List<Requirement> list = new List<Requirement>();
		GameObject val = null;
		foreach (ResourceElement craftingResource in craftingResources)
		{
			if (MyReferences.listOfItemPrefabs.ContainsKey(StringExtensionMethods.GetStableHashCode(craftingResource.prefabItemName)))
			{
				val = MyReferences.listOfItemPrefabs[StringExtensionMethods.GetStableHashCode(craftingResource.prefabItemName)];
			}
			else
			{
				val = ObjectDB.instance.GetItemPrefab(craftingResource.prefabItemName);
				if ((Object)(object)val != (Object)null && !MyReferences.listOfItemPrefabs.ContainsKey(StringExtensionMethods.GetStableHashCode(craftingResource.prefabItemName)))
				{
					MyReferences.listOfItemPrefabs.Add(StringExtensionMethods.GetStableHashCode(craftingResource.prefabItemName), val);
				}
			}
			list.Add(new Requirement
			{
				m_resItem = val.GetComponent<ItemDrop>(),
				m_amount = craftingResource.amount,
				m_amountPerLevel = craftingResource.amountPerLevel,
				m_recover = craftingResource.recover
			});
			val = null;
		}
		myPiece.GetComponent<Piece>().m_resources = list.ToArray();
	}

	public void CompileAndAddPiece()
	{
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Expected O, but got Unknown
		//IL_010c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Expected O, but got Unknown
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Expected O, but got Unknown
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ac: Expected O, but got Unknown
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_013b: Expected O, but got Unknown
		//IL_023e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0245: Expected O, but got Unknown
		//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Expected O, but got Unknown
		//IL_0266: Unknown result type (might be due to invalid IL or missing references)
		//IL_026d: Expected O, but got Unknown
		Piece component = myPiece.GetComponent<Piece>();
		if ((Object)(object)component != (Object)null)
		{
			component.m_craftingStation = MyReferences.listOfCraftingStations[StringExtensionMethods.GetStableHashCode(craftingStationName)];
			if (placeEffectNames != null && placeEffectNames.Count > 0)
			{
				EffectList val = new EffectList();
				List<EffectData> list = new List<EffectData>();
				foreach (string placeEffectName in placeEffectNames)
				{
					EffectData val2 = new EffectData();
					val2.m_prefab = MyReferences.GetStoredEffectPrefab(placeEffectName);
					list.Add(val2);
				}
				val.m_effectPrefabs = list.ToArray();
				component.m_placeEffect = val;
			}
		}
		WearNTear component2 = myPiece.GetComponent<WearNTear>();
		if ((Object)(object)component2 != (Object)null)
		{
			if (destoryedEffectNames != null && destoryedEffectNames.Count > 0)
			{
				EffectList val3 = new EffectList();
				List<EffectData> list2 = new List<EffectData>();
				foreach (string destoryedEffectName in destoryedEffectNames)
				{
					EffectData val4 = new EffectData();
					val4.m_prefab = MyReferences.GetStoredEffectPrefab(destoryedEffectName);
					list2.Add(val4);
				}
				val3.m_effectPrefabs = list2.ToArray();
				component2.m_destroyedEffect = val3;
			}
			if (hitEffectNames != null && hitEffectNames.Count > 0)
			{
				EffectList val5 = new EffectList();
				List<EffectData> list3 = new List<EffectData>();
				foreach (string hitEffectName in hitEffectNames)
				{
					EffectData val6 = new EffectData();
					val6.m_prefab = MyReferences.GetStoredEffectPrefab(hitEffectName);
					list3.Add(val6);
				}
				val5.m_effectPrefabs = list3.ToArray();
				component2.m_hitEffect = val5;
			}
			if (switchEffectNames != null && switchEffectNames.Count > 0)
			{
				EffectList val7 = new EffectList();
				List<EffectData> list4 = new List<EffectData>();
				foreach (string switchEffectName in switchEffectNames)
				{
					EffectData val8 = new EffectData();
					val8.m_prefab = MyReferences.GetStoredEffectPrefab(switchEffectName);
					list4.Add(val8);
				}
				val7.m_effectPrefabs = list4.ToArray();
				component2.m_switchEffect = val7;
			}
		}
		UpdateRequirements();
		AddPiece();
	}
}
internal interface ICustomSerializable
{
	string GetPrettyOutput();
}
public static class MyReferences
{
	public static Dictionary<int, CraftingStation> listOfCraftingStations = new Dictionary<int, CraftingStation>();

	public static Dictionary<int, CookingStation> listOfCookingStations = new Dictionary<int, CookingStation>();

	public static Dictionary<int, StatusEffect> myStatusEffects = new Dictionary<int, StatusEffect>();

	public static List<int> prefabsThatUpgradeAtLevelOneAlways = new List<int>();

	public static Dictionary<int, GameObject> listOfAllGameObjects = new Dictionary<int, GameObject>();

	public static Dictionary<int, GameObject> listOfItemPrefabs = new Dictionary<int, GameObject>();

	public static Dictionary<int, GameObject> listOfPieces = new Dictionary<int, GameObject>();

	public static Dictionary<int, GameObject> listOfEffects = new Dictionary<int, GameObject>();

	public static Dictionary<int, Material> listOfMaterials = new Dictionary<int, Material>();

	public static Dictionary<int, Material> listOfNewMaterials = new Dictionary<int, Material>();

	public static Dictionary<int, Mesh> listOfMeshes = new Dictionary<int, Mesh>();

	public static Dictionary<int, Shader> listOfShaders = new Dictionary<int, Shader>();

	public static Dictionary<int, Attack> myListOfExtraAttacks = new Dictionary<int, Attack>();

	public static void CleanupReferences()
	{
		listOfAllGameObjects = null;
		listOfItemPrefabs = null;
		listOfPieces = null;
		listOfEffects = null;
		listOfMaterials = null;
		listOfNewMaterials = null;
		listOfMeshes = null;
		listOfShaders = null;
	}

	public static GameObject GetStoredEffectPrefab(int hash)
	{
		if (listOfEffects.ContainsKey(hash))
		{
			return listOfEffects[hash];
		}
		return null;
	}

	public static GameObject GetStoredEffectPrefab(string name)
	{
		int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
		return GetStoredEffectPrefab(stableHashCode);
	}

	public static void SetStoredEffectPrefab(int hash, GameObject prefab)
	{
		listOfEffects[hash] = prefab;
	}

	public static void SetStoredEffectPrefab(string name, GameObject prefab)
	{
		int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
		SetStoredEffectPrefab(stableHashCode, prefab);
	}

	public static Material GetStoredMaterial(int hash)
	{
		if (listOfNewMaterials.ContainsKey(hash))
		{
			return listOfNewMaterials[hash];
		}
		if (listOfMaterials.ContainsKey(hash))
		{
			return listOfMaterials[hash];
		}
		return null;
	}

	public static Material GetStoredMaterial(string name)
	{
		int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
		return GetStoredMaterial(stableHashCode);
	}

	public static void SetStoredMaterial(int hash, Material mat)
	{
		listOfMaterials[hash] = mat;
	}

	public static void SetStoredMaterial(string name, Material mat)
	{
		int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
		SetStoredMaterial(stableHashCode, mat);
	}

	public static void SetNewStoredMaterial(int hash, Material mat)
	{
		listOfNewMaterials[hash] = mat;
	}

	public static void SetNewStoredMaterial(string name, Material mat)
	{
		int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
		SetNewStoredMaterial(stableHashCode, mat);
	}

	public static Shader GetStoredShader(int hash)
	{
		if (listOfShaders.ContainsKey(hash))
		{
			return listOfShaders[hash];
		}
		return null;
	}

	public static Shader GetStoredShader(string name)
	{
		int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
		return GetStoredShader(stableHashCode);
	}

	public static void SetStoredShader(string name, Shader shader)
	{
		int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
		SetStoredShader(stableHashCode, shader);
	}

	public static void SetStoredShader(int hash, Shader shader)
	{
		listOfShaders[hash] = shader;
	}

	public static void SetStoredGameObjectPrefab(int hash, GameObject go)
	{
		listOfAllGameObjects[hash] = go;
	}

	public static void SetStoredGameObjectPrefab(string name, GameObject go)
	{
		if ((Object)(object)go != (Object)null)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			SetStoredGameObjectPrefab(stableHashCode, go);
		}
	}

	public static void SetStoredItemPrefab(int hash, GameObject go)
	{
		listOfItemPrefabs[hash] = go;
		SetStoredGameObjectPrefab(hash, go);
	}

	public static void SetStoredItemPrefab(string name, GameObject go)
	{
		int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
		SetStoredItemPrefab(stableHashCode, go);
	}

	public static void SetStoredPiecePrefab(int hash, GameObject go)
	{
		listOfPieces[hash] = go;
		SetStoredGameObjectPrefab(hash, go);
	}

	public static void SetStoredPiecePrefab(string name, GameObject go)
	{
		int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
		SetStoredPiecePrefab(stableHashCode, go);
	}

	public static void SetStoredAttack(int hash, Attack attack)
	{
		myListOfExtraAttacks[hash] = attack;
	}

	public static void SetStoredAttack(string name, Attack attack)
	{
		int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
		SetStoredAttack(stableHashCode, attack);
	}

	public static void TryAddToStatusEffectList(StatusEffect effect)
	{
		if (!myStatusEffects.ContainsKey(StringExtensionMethods.GetStableHashCode(((Object)effect).name)))
		{
			myStatusEffects.Add(StringExtensionMethods.GetStableHashCode(((Object)effect).name), effect);
		}
	}

	public static void TryExtractEffectsFromItemDropShared(SharedData shared)
	{
		CollectEffectsFromItemDrop(shared.m_hitEffect);
		CollectEffectsFromItemDrop(shared.m_hitTerrainEffect);
		CollectEffectsFromItemDrop(shared.m_holdStartEffect);
		CollectEffectsFromItemDrop(shared.m_startEffect);
		CollectEffectsFromItemDrop(shared.m_triggerEffect);
		CollectEffectsFromItemDrop(shared.m_blockEffect);
		CollectEffectsFromItemDrop(shared.m_trailStartEffect);
	}

	private static void CollectEffectsFromItemDrop(EffectList list)
	{
		if (list == null || list.m_effectPrefabs == null || list.m_effectPrefabs.Length == 0)
		{
			return;
		}
		EffectData[] effectPrefabs = list.m_effectPrefabs;
		foreach (EffectData val in effectPrefabs)
		{
			if (val != null && (Object)(object)val.m_prefab != (Object)null)
			{
				SetStoredEffectPrefab(((Object)val.m_prefab).name, val.m_prefab);
			}
		}
	}
}
public class CustomItem
{
	public GameObject gameObject;

	public EffectsManager effectHandler = new EffectsManager();

	public PrefabFixer prefabFixer = new PrefabFixer();

	public CustomItem(GameObject gameObject)
	{
		this.gameObject = gameObject;
	}

	public void FixReferences()
	{
		effectHandler.ApplyEffects(gameObject);
		prefabFixer.Run(ref gameObject);
	}
}
public class CustomLocalization
{
	private string currentLanguage = "English";

	private string fileSuffix = "_localization";

	private List<string> localizationLines = new List<string>();

	public Dictionary<string, string> localizedWords = new Dictionary<string, string>();

	public bool addedLocalization = false;

	public CustomLocalization()
	{
		string text = PlayerPrefs.GetString("language", "");
		if (text != "")
		{
			currentLanguage = text;
		}
	}

	public void LoadLocalization(string bepinexConfigPath)
	{
		string path = bepinexConfigPath + fileSuffix + ".tsv";
		bool flag = false;
		if (Plugin.useLocalizationInConfigFolder)
		{
			try
			{
				using StreamReader reader = new StreamReader(path);
				ReadLocalization(reader);
				flag = true;
			}
			catch (FileNotFoundException)
			{
				Plugin.Log.LogWarning((object)("Failed to find '" + bepinexConfigPath + fileSuffix + "' will create config of same name with default values."));
			}
			catch (IOException ex2)
			{
				Plugin.Log.LogError((object)("An IO Exception was thrown. [" + fileSuffix + "]"));
				Plugin.Log.LogError((object)ex2.Message);
				Plugin.Log.LogError((object)ex2.StackTrace);
			}
		}
		if (!flag)
		{
			ReadDefaultLocalization();
			if (Plugin.useLocalizationInConfigFolder)
			{
				WriteLocalization(path);
			}
		}
		ParseLocalization();
	}

	private void ParseLocalization()
	{
		int num = -1;
		bool flag = true;
		int num2 = 0;
		foreach (string localizationLine in localizationLines)
		{
			try
			{
				string[] array = localizationLine.Split(new char[1] { '\t' });
				if (flag)
				{
					flag = false;
					for (int i = 1; i < array.Length; i++)
					{
						if (array[i] == currentLanguage)
						{
							num = i;
							break;
						}
					}
				}
				else if (num > -1)
				{
					FilterData(array, num);
				}
				num2++;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)$"Exception Thrown trying to localize line {num2}: <{localizationLine}>");
				Plugin.Log.LogError((object)("Exception Message: <" + ex.Message + ">"));
			}
		}
	}

	private void FilterData(string[] splitData, int languageIndex)
	{
		string text = splitData[languageIndex];
		if (text.Trim() == string.Empty)
		{
			text = splitData[1];
		}
		localizedWords[splitData[0]] = text;
	}

	private void WriteLocalization(string path)
	{
		StringBuilder stringBuilder = new StringBuilder();
		foreach (string localizationLine in localizationLines)
		{
			stringBuilder.AppendLine(localizationLine);
		}
		using StreamWriter streamWriter = new StreamWriter(path);
		streamWriter.Write(stringBuilder.ToString());
	}

	private void ReadLocalization(StreamReader reader)
	{
		while (!reader.EndOfStream)
		{
			localizationLines.Add(reader.ReadLine());
		}
	}

	private void ReadDefaultLocalization()
	{
		Assembly executingAssembly = Assembly.GetExecutingAssembly();
		string name = executingAssembly.GetManifestResourceNames().Single((string str) => str.EndsWith("localization.tsv"));
		using Stream stream = executingAssembly.GetManifestResourceStream(name);
		using StreamReader streamReader = new StreamReader(stream);
		while (!streamReader.EndOfStream)
		{
			string item = streamReader.ReadLine();
			localizationLines.Add(item);
		}
	}
}
public static class ItemManager
{
	private static AssetBundle assetBundle;

	private static RecipeHelper currentRecipeHelper;

	private static GameObject currentItem;

	private static CustomItem currentCustom;

	private static ItemDrop id;

	private static Color colBlackMetal = new Color(0.3820755f, 1f, 0.3991793f, 1f);

	public static void BuildLists()
	{
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_2505: Unknown result type (might be due to invalid IL or missing references)
		//IL_1ecd: Unknown result type (might be due to invalid IL or missing references)
		//IL_1ed2: Unknown result type (might be due to invalid IL or missing references)
		//IL_282b: Unknown result type (might be due to invalid IL or missing references)
		//IL_2bb9: Unknown result type (might be due to invalid IL or missing references)
		//IL_2edf: Unknown result type (might be due to invalid IL or missing references)
		//IL_3355: Unknown result type (might be due to invalid IL or missing references)
		//IL_3682: Unknown result type (might be due to invalid IL or missing references)
		//IL_43f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_4671: Unknown result type (might be due to invalid IL or missing references)
		//IL_48f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_4b73: Unknown result type (might be due to invalid IL or missing references)
		//IL_4dee: Unknown result type (might be due to invalid IL or missing references)
		//IL_50ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_53ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_568e: Unknown result type (might be due to invalid IL or missing references)
		//IL_596e: Unknown result type (might be due to invalid IL or missing references)
		//IL_5be9: Unknown result type (might be due to invalid IL or missing references)
		//IL_5e64: Unknown result type (might be due to invalid IL or missing references)
		//IL_60df: Unknown result type (might be due to invalid IL or missing references)
		//IL_635a: Unknown result type (might be due to invalid IL or missing references)
		//IL_663a: Unknown result type (might be due to invalid IL or missing references)
		//IL_691a: Unknown result type (might be due to invalid IL or missing references)
		//IL_6bfa: Unknown result type (might be due to invalid IL or missing references)
		assetBundle = GetAssetBundleFromResources("twohandedweapons");
		StatusEffect effect = assetBundle.LoadAsset<StatusEffect>("SEUnholyRegenHTD");
		MyReferences.TryAddToStatusEffectList(effect);
		effect = assetBundle.LoadAsset<StatusEffect>("SEBoarBerserkerSetHTD");
		SE_Stats_ProgressiveSet sE_Stats_ProgressiveSet = ScriptableObject.CreateInstance<SE_Stats_ProgressiveSet>();
		((StatusEffect)sE_Stats_ProgressiveSet).m_name = effect.m_name;
		((StatusEffect)sE_Stats_ProgressiveSet).m_icon = effect.m_icon;
		((StatusEffect)sE_Stats_ProgressiveSet).m_tooltip = effect.m_tooltip;
		((SE_Stats)sE_Stats_ProgressiveSet).m_runStaminaDrainModifier = -0.2f;
		((SE_Stats)sE_Stats_ProgressiveSet).m_jumpStaminaUseModifier = -0.2f;
		((SE_Stats)sE_Stats_ProgressiveSet).m_healthRegenMultiplier = 0.5f;
		((SE_Stats)sE_Stats_ProgressiveSet).m_staminaRegenMultiplier = 1.6f;
		((SE_Stats)sE_Stats_ProgressiveSet).m_modifyAttackSkill = (SkillType)999;
		((SE_Stats)sE_Stats_ProgressiveSet).m_damageModifier = 1.15f;
		((SE_Stats)sE_Stats_ProgressiveSet).m_speedModifier = 0.1f;
		((Object)sE_Stats_ProgressiveSet).name = "SEBoarBerserkerSetHTD";
		MyReferences.TryAddToStatusEffectList((StatusEffect)(object)sE_Stats_ProgressiveSet);
		currentItem = ExtractGameObjectFromBundle(assetBundle, "ArmorHelmetBoarHTD");
		id = currentItem.GetComponent<ItemDrop>();
		id.m_itemData.m_shared.m_setStatusEffect = (StatusEffect)(object)sE_Stats_ProgressiveSet;
		currentRecipeHelper = ApplyConfigChangesAndRecipes(ref currentItem);
		if (currentRecipeHelper == null)
		{
			currentRecipeHelper = new RecipeHelper(currentItem, "piece_workbench", 1, 1);
			currentRecipeHelper.AddResource("TrophyBoar", 1, 0).AddResource("LeatherScraps", 6, 3).AddResource("BoneFragments", 12, 6);
		}
		Plugin.customConfigInstance.AddArmorDataAsConfigRecord(currentItem);
		Plugin.customConfigInstance.AddRecipeAsConfigRecord(currentRecipeHelper);
		currentCustom = new CustomItem(currentItem);
		currentCustom.prefabFixer.New("model0", 4).AddMaterialTask("", useCurrentMaterial: true).FixShaderOnly()
			.SetShader("custom/creature");
		currentCustom.prefabFixer.Current().AddMaterialTask(MaterialScraper.boarTusk).SetMaterialIndex(1);
		currentCustom.prefabFixer.Current().AddMaterialTask(MaterialScraper.boarTexture, useCurrentMaterial: true).SetShader("custom/creature")
			.SetMaterialIndex(2);
		Plugin.myCustomItems.Add(currentCustom);
		Plugin.myRecipeHelperList.Add(currentRecipeHelper);
		currentItem = ExtractGameObjectFromBundle(assetBundle, "ArmorChestBoarHTD");
		id = currentItem.GetComponent<ItemDrop>();
		id.m_itemData.m_shared.m_setStatusEffect = (StatusEffect)(object)sE_Stats_ProgressiveSet;
		currentRecipeHelper = ApplyConfigChangesAndRecipes(ref currentItem);
		if (currentRecipeHelper == null)
		{
			currentRecipeHelper = new RecipeHelper(currentItem, "piece_workbench", 1, 1);
			currentRecipeHelper.AddResource("TrophyBoar", 1, 0).AddResource("LeatherScraps", 10, 4).AddResource("BoneFragments", 12, 6);
		}
		Plugin.customConfigInstance.AddArmorDataAsConfigRecord(currentItem);
		Plugin.customConfigInstance.AddRecipeAsConfigRecord(currentRecipeHelper);
		currentCustom = new CustomItem(currentItem);
		currentCustom.prefabFixer.New("model0", 8).AddMaterialTask(MaterialScraper.boarTusk).SetMaterialIndex(1);
		currentCustom.prefabFixer.New("model1", 6).AddMaterialTask(MaterialScraper.boarTusk).SetMaterialIndex(1);
		currentCustom.prefabFixer.New("log").AddMaterialTask("rags");
		currentCustom.prefabFixer.Current().AddMeshTask(MeshScraper.clothesGroundMesh);
		Plugin.myCustomItems.Add(currentCustom);
		Plugin.myRecipeHelperList.Add(currentRecipeHelper);
		currentItem = ExtractGameObjectFromBundle(assetBundle, "ArmorLegsBoarHTD");
		id = currentItem.GetComponent<ItemDrop>();
		id.m_itemData.m_shared.m_setStatusEffect = (StatusEffect)(object)sE_Stats_ProgressiveSet;
		currentRecipeHelper = ApplyConfigChangesAndRecipes(ref currentItem);
		if (currentRecipeHelper == null)
		{
			currentRecipeHelper = new RecipeHelper(currentItem, "piece_workbench", 1, 1);
			currentRecipeHelper.AddResource("TrophyBoar", 1, 0).AddResource("LeatherScraps", 10, 4);
		}
		Plugin.customConfigInstance.AddArmorDataAsConfigRecord(currentItem);
		Plugin.customConfigInstance.AddRecipeAsConfigRecord(currentRecipeHelper);
		currentCustom = new CustomItem(currentItem);
		currentCustom.prefabFixer.New("model0", 4).AddMaterialTask(MaterialScraper.boarTusk).SetMaterialIndex(1);
		currentCustom.prefabFixer.New("model1", 3).AddMaterialTask(MaterialScraper.boarTusk).SetMaterialIndex(1);
		currentCustom.prefabFixer.New("log").AddMaterialTask("rags");
		currentCustom.prefabFixer.Current().AddMeshTask(MeshScraper.clothesGroundMesh);
		Plugin.myCustomItems.Add(currentCustom);
		Plugin.myRecipeHelperList.Add(currentRecipeHelper);
		currentItem = ExtractGameObjectFromBundle(assetBundle, "ArmorShoulderBoarHTD");
		id = currentItem.GetComponent<ItemDrop>();
		id.m_itemData.m_shared.m_setStatusEffect = (StatusEffect)(object)sE_Stats_ProgressiveSet;
		currentRecipeHelper = ApplyConfigChangesAndRecipes(ref currentItem);
		if (currentRecipeHelper == null)
		{
			currentRecipeHelper = new RecipeHelper(currentItem, "piece_workbench", 1, 1);
			currentRecipeHelper.AddResource("TrophyBoar", 1, 0).AddResource("LeatherScraps", 8, 3).AddResource("BoneFragments", 6, 3);
		}
		Plugin.customConfigInstance.AddArmorDataAsConfigRecord(currentItem);
		Plugin.customConfigInstance.AddRecipeAsConfigRecord(currentRecipeHelper);
		currentCustom = new CustomItem(currentItem);
		currentCustom.prefabFixer.New("model0", 4).AddMaterialTask(MaterialScraper.boarTusk).SetMaterialIndex(1);
		currentCustom.prefabFixer.New("log").AddMaterialTask("rags");
		currentCustom.prefabFixer.Current().AddMeshTask(MeshScraper.clothesGroundMesh);
		Plugin.myCustomItems.Add(currentCustom);
		Plugin.myRecipeHelperList.Add(currentRecipeHelper);
		currentItem = ExtractGameObjectFromBundle(assetBundle, "WoodSwordHTD");
		id = currentItem.GetComponent<ItemDrop>();
		currentRecipeHelper = ApplyConfigChangesAndRecipes(ref currentItem);
		if (currentRecipeHelper == null)
		{
			currentRecipeHelper = new RecipeHelper(currentItem, "", 1, 1);
			currentRecipeHelper.AddResource("Wood", 4, 2);
		}
		currentRecipeHelper.SetRepairStation("piece_workbench");
		Plugin.customConfigInstance.AddItemDataAsConfigRecord(currentItem);
		Plugin.customConfigInstance.AddRecipeAsConfigRecord(currentRecipeHelper);
		Plugin.myRecipeHelperList.Add(currentRecipeHelper);
		currentCustom = new CustomItem(currentItem);
		currentCustom.prefabFixer.New("model").AddMeshTask(MeshScraper.woodMesh);
		currentCustom.prefabFixer.Current().AddMaterialTask("wood_item");
		currentCustom.effectHandler.AddEffect("vfx_clubhit", EffectsManager.EffectList.HIT).AddEffect("sfx_club_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("vfx_clubhit", EffectsManager.EffectList.HIT_TERRAIN).AddEffect("sfx_club_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("sfx_wood_blocked", EffectsManager.EffectList.BLOCK).AddEffect("vfx_blocked").AddEffect("fx_block_camshake");
		currentCustom.effectHandler.AddEffect("fx_swing_camshake", EffectsManager.EffectList.TRIGGER);
		currentCustom.effectHandler.AddEffect("sfx_club_swing", EffectsManager.EffectList.TRAIL);
		Plugin.myCustomItems.Add(currentCustom);
		currentItem = ExtractGameObjectFromBundle(assetBundle, "WoodPolearmHTD");
		id = currentItem.GetComponent<ItemDrop>();
		currentRecipeHelper = ApplyConfigChangesAndRecipes(ref currentItem);
		if (currentRecipeHelper == null)
		{
			currentRecipeHelper = new RecipeHelper(currentItem, "", 1, 1);
			currentRecipeHelper.AddResource("Wood", 6, 2);
		}
		currentRecipeHelper.SetRepairStation("piece_workbench");
		Plugin.customConfigInstance.AddItemDataAsConfigRecord(currentItem);
		Plugin.customConfigInstance.AddRecipeAsConfigRecord(currentRecipeHelper);
		Plugin.myRecipeHelperList.Add(currentRecipeHelper);
		currentCustom = new CustomItem(currentItem);
		currentCustom.prefabFixer.New("model").AddMeshTask(MeshScraper.stakeWallMesh);
		currentCustom.prefabFixer.Current().AddMaterialTask("stake");
		currentCustom.effectHandler.AddEffect("vfx_clubhit", EffectsManager.EffectList.HIT).AddEffect("sfx_club_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("vfx_clubhit", EffectsManager.EffectList.HIT_TERRAIN).AddEffect("sfx_club_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("sfx_wood_blocked", EffectsManager.EffectList.BLOCK).AddEffect("vfx_blocked").AddEffect("fx_block_camshake");
		currentCustom.effectHandler.AddEffect("fx_swing_camshake", EffectsManager.EffectList.TRIGGER);
		currentCustom.effectHandler.AddEffect("sfx_club_swing", EffectsManager.EffectList.TRAIL);
		Plugin.myCustomItems.Add(currentCustom);
		currentItem = ExtractGameObjectFromBundle(assetBundle, "LeatherFistsHTD");
		id = currentItem.GetComponent<ItemDrop>();
		currentRecipeHelper = ApplyConfigChangesAndRecipes(ref currentItem);
		if (currentRecipeHelper == null)
		{
			currentRecipeHelper = new RecipeHelper(currentItem, "piece_workbench", 1, 1);
			currentRecipeHelper.AddResource("LeatherScraps", 4, 2);
		}
		Plugin.customConfigInstance.AddItemDataAsConfigRecord(currentItem);
		Plugin.customConfigInstance.AddRecipeAsConfigRecord(currentRecipeHelper);
		Plugin.myRecipeHelperList.Add(currentRecipeHelper);
		currentCustom = new CustomItem(currentItem);
		currentCustom.prefabFixer.New("LeatherFists").AddMaterialTask("", useCurrentMaterial: true).FixShaderOnly()
			.SetShader("custom/creature");
		currentCustom.effectHandler.AddEffect("vfx_clubhit", EffectsManager.EffectList.HIT).AddEffect("sfx_unarmed_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("vfx_clubhit", EffectsManager.EffectList.HIT_TERRAIN).AddEffect("sfx_unarmed_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("sfx_unarmed_blocked", EffectsManager.EffectList.BLOCK).AddEffect("vfx_blocked").AddEffect("fx_block_camshake");
		currentCustom.effectHandler.AddEffect("sfx_unarmed_swing", EffectsManager.EffectList.START);
		currentCustom.effectHandler.AddEffect("fx_swing_camshake", EffectsManager.EffectList.TRIGGER);
		currentCustom.effectHandler.AddEffect("sfx_unarmed_swing", EffectsManager.EffectList.TRAIL);
		Plugin.myCustomItems.Add(currentCustom);
		currentItem = ExtractGameObjectFromBundle(assetBundle, "BronzeFistsHTD");
		id = currentItem.GetComponent<ItemDrop>();
		currentRecipeHelper = ApplyConfigChangesAndRecipes(ref currentItem);
		if (currentRecipeHelper == null)
		{
			currentRecipeHelper = new RecipeHelper(currentItem, "forge", 1, 1);
			currentRecipeHelper.AddResource("Bronze", 5, 3).AddResource("LeatherScraps", 5, 3);
		}
		Plugin.customConfigInstance.AddItemDataAsConfigRecord(currentItem);
		Plugin.customConfigInstance.AddRecipeAsConfigRecord(currentRecipeHelper);
		Plugin.myRecipeHelperList.Add(currentRecipeHelper);
		currentCustom = new CustomItem(currentItem);
		currentCustom.effectHandler.AddEffect("vfx_HitSparks", EffectsManager.EffectList.HIT).AddEffect("sfx_sword_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("vfx_HitSparks", EffectsManager.EffectList.HIT_TERRAIN).AddEffect("sfx_sword_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("sfx_metal_blocked", EffectsManager.EffectList.BLOCK).AddEffect("vfx_blocked").AddEffect("fx_block_camshake");
		currentCustom.effectHandler.AddEffect("sfx_unarmed_swing", EffectsManager.EffectList.START);
		currentCustom.effectHandler.AddEffect("fx_swing_camshake", EffectsManager.EffectList.TRIGGER);
		currentCustom.effectHandler.AddEffect("sfx_unarmed_swing", EffectsManager.EffectList.TRAIL);
		Plugin.myCustomItems.Add(currentCustom);
		currentItem = ExtractGameObjectFromBundle(assetBundle, "IronFistsHTD");
		id = currentItem.GetComponent<ItemDrop>();
		currentRecipeHelper = ApplyConfigChangesAndRecipes(ref currentItem);
		if (currentRecipeHelper == null)
		{
			currentRecipeHelper = new RecipeHelper(currentItem, "forge", 1, 1);
			currentRecipeHelper.AddResource("Iron", 5, 3).AddResource("LeatherScraps", 5, 3);
		}
		Plugin.customConfigInstance.AddItemDataAsConfigRecord(currentItem);
		Plugin.customConfigInstance.AddRecipeAsConfigRecord(currentRecipeHelper);
		Plugin.myRecipeHelperList.Add(currentRecipeHelper);
		currentCustom = new CustomItem(currentItem);
		currentCustom.effectHandler.AddEffect("vfx_HitSparks", EffectsManager.EffectList.HIT).AddEffect("sfx_sword_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("vfx_HitSparks", EffectsManager.EffectList.HIT_TERRAIN).AddEffect("sfx_sword_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("sfx_metal_blocked", EffectsManager.EffectList.BLOCK).AddEffect("vfx_blocked").AddEffect("fx_block_camshake");
		currentCustom.effectHandler.AddEffect("sfx_unarmed_swing", EffectsManager.EffectList.START);
		currentCustom.effectHandler.AddEffect("fx_swing_camshake", EffectsManager.EffectList.TRIGGER);
		currentCustom.effectHandler.AddEffect("sfx_unarmed_swing", EffectsManager.EffectList.TRAIL);
		Plugin.myCustomItems.Add(currentCustom);
		currentItem = ExtractGameObjectFromBundle(assetBundle, "DeerFistsHTD");
		id = currentItem.GetComponent<ItemDrop>();
		currentRecipeHelper = ApplyConfigChangesAndRecipes(ref currentItem);
		if (currentRecipeHelper == null)
		{
			currentRecipeHelper = new RecipeHelper(currentItem, "piece_workbench", 1, 1);
			currentRecipeHelper.AddResource("HardAntler", 2, 6).AddResource("TrophyDeer", 1, 2).AddResource("LeatherScraps", 8, 8);
		}
		Plugin.customConfigInstance.AddItemDataAsConfigRecord(currentItem);
		Plugin.customConfigInstance.AddRecipeAsConfigRecord(currentRecipeHelper);
		Plugin.myRecipeHelperList.Add(currentRecipeHelper);
		currentCustom = new CustomItem(currentItem);
		currentCustom.prefabFixer.New("FistBuckAndDoeMesh").AddMaterialTask("eikthyrnir_body").SetMaterialIndex(1);
		currentCustom.prefabFixer.New("model").AddMaterialTask("eikthyrnir_body").SetMaterialIndex(1);
		currentCustom.effectHandler.AddEffect("vfx_clubhit", EffectsManager.EffectList.HIT).AddEffect("sfx_club_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("vfx_clubhit", EffectsManager.EffectList.HIT_TERRAIN).AddEffect("sfx_club_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("sfx_metal_blocked", EffectsManager.EffectList.BLOCK).AddEffect("vfx_blocked").AddEffect("fx_block_camshake");
		currentCustom.effectHandler.AddEffect("sfx_unarmed_swing", EffectsManager.EffectList.START);
		currentCustom.effectHandler.AddEffect("fx_swing_camshake", EffectsManager.EffectList.TRIGGER);
		currentCustom.effectHandler.AddEffect("sfx_unarmed_swing", EffectsManager.EffectList.TRAIL);
		Plugin.myCustomItems.Add(currentCustom);
		currentItem = ExtractGameObjectFromBundle(assetBundle, "SilverFistsHTD");
		id = currentItem.GetComponent<ItemDrop>();
		currentRecipeHelper = ApplyConfigChangesAndRecipes(ref currentItem);
		if (currentRecipeHelper == null)
		{
			currentRecipeHelper = new RecipeHelper(currentItem, "forge", 1, 1);
			currentRecipeHelper.AddResource("WolfPelt", 8, 4).AddResource("Silver", 10, 5).AddResource("LeatherScraps", 9, 3)
				.AddResource("Iron", 5, 3);
		}
		Plugin.customConfigInstance.AddItemDataAsConfigRecord(currentItem);
		Plugin.customConfigInstance.AddRecipeAsConfigRecord(currentRecipeHelper);
		Plugin.myRecipeHelperList.Add(currentRecipeHelper);
		currentCustom = new CustomItem(currentItem);
		currentCustom.prefabFixer.New("SilverGlovesSMR").AddMaterialTask("silverarmourchest_mat").SetMaterialIndex(3);
		currentCustom.prefabFixer.New("model").AddMaterialTask("silverarmourchest_mat").SetMaterialIndex(3);
		currentCustom.effectHandler.AddEffect("vfx_HitSparks", EffectsManager.EffectList.HIT).AddEffect("sfx_sword_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("vfx_HitSparks", EffectsManager.EffectList.HIT_TERRAIN).AddEffect("sfx_sword_hit").AddEffect("fx_hit_camshake");
		currentCustom.effectHandler.AddEffect("sfx_metal_blocked", EffectsManager.EffectList.BLOCK).AddEffect("vfx_blocked").AddEffect("fx_block_camshake");
		currentCustom.effectHandler.AddEffect("sfx_unarmed_swing", EffectsManager.EffectList.START);
		currentCustom.effectHandler.AddEffect("fx_swing_camshake", EffectsManager.EffectList.TRIGGER);
		currentCustom.effectHandler.AddEffect("sfx_unarmed_swing", EffectsManager.E