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.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ValheimArmory")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ValheimArmory")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("0.0.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.0")]
namespace ValheimArmory;

internal class ItemEffects
{
}
internal class EtirBuff : MonoBehaviour
{
	private static bool buffApplied;

	private ZNetView zNetView;

	private ItemDrop itemMetaData;

	private float bonus_value = 15f;

	private void Awake()
	{
		zNetView = ((Component)this).GetComponent<ZNetView>();
		itemMetaData = ((Component)this).GetComponent<ItemDrop>();
	}

	public void SetBonus(float value)
	{
		bonus_value = value;
	}

	private void Update()
	{
		Logger.LogInfo((object)$"Staff checking status: {zNetView.IsValid()} {Player.m_localPlayer.IsEquipActionQueued(itemMetaData.m_itemData)}");
		if (zNetView.IsValid() && Player.m_localPlayer.IsEquipActionQueued(itemMetaData.m_itemData))
		{
			if (!buffApplied)
			{
				Logger.LogInfo((object)"Eitr buff applied");
				buffApplied = true;
				float num = ((Character)Player.m_localPlayer).GetMaxEitr() + bonus_value;
				float maxHealth = ((Character)Player.m_localPlayer).GetMaxHealth();
				float maxStamina = ((Character)Player.m_localPlayer).GetMaxStamina();
				Player.m_localPlayer.GetTotalFoodValue(ref maxHealth, ref maxStamina, ref num);
				Player localPlayer = Player.m_localPlayer;
				localPlayer.m_maxEitr += 20f;
				Player localPlayer2 = Player.m_localPlayer;
				localPlayer2.m_eitr += 20f;
			}
			else
			{
				Logger.LogInfo((object)"Eitr buff removed");
				Player localPlayer3 = Player.m_localPlayer;
				localPlayer3.m_maxEitr -= 20f;
			}
		}
	}
}
internal class ValheimArmoryItems
{
	private AssetBundle EmbeddedResourceBundle = ValheimArmory.EmbeddedResourceBundle;

	public ValheimArmoryItems()
	{
		if (VAConfig.EnableDebugMode.Value)
		{
			Logger.LogInfo((object)"Loading Items.");
		}
		LoadArrows();
		LoadBows();
		LoadSwords();
		LoadAxes();
		LoadHammers();
		LoadAtgeirs();
		LoadDaggers();
		LoadShields();
		LoadSpears();
		LoadMaces();
		LoadFists();
		LoadMagic();
		LoadPickaxes();
		LoadNonCraftables();
	}

	private void LoadArrows()
	{
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Black Metal Arrow" },
			{ "catagory", "Arrows" },
			{ "prefab", "VAArrowGreenMetal" },
			{ "sprite", "arrow_greenmetal" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(52f, 0f, 200f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(26f, 0f, 200f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(8, 0)
			},
			{
				"BlackMetal",
				new Tuple<int, int>(2, 0)
			},
			{
				"Feathers",
				new Tuple<int, int>(2, 0)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Bone Arrow" },
			{ "catagory", "Arrows" },
			{ "prefab", "VAArrowBone" },
			{ "sprite", "bone_arrow" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(32f, 0f, 200f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"BoneFragments",
				new Tuple<int, int>(8, 0)
			},
			{
				"Feathers",
				new Tuple<int, int>(2, 0)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Surtling Fire Arrow" },
			{ "catagory", "Arrows" },
			{ "prefab", "VAarrow_surtling_fire" },
			{ "sprite", "surtlingcore_arrow" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
			},
			{
				"fire",
				new Tuple<float, float, float, bool>(52f, 0f, 200f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(26f, 0f, 200f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(8, 0)
			},
			{
				"Obsidian",
				new Tuple<int, int>(4, 0)
			},
			{
				"Feathers",
				new Tuple<int, int>(2, 0)
			},
			{
				"SurtlingCore",
				new Tuple<int, int>(1, 0)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Ancient Wood Arrow" },
			{ "catagory", "Arrows" },
			{ "prefab", "VAarrowancient" },
			{ "sprite", "ancient_arrow" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(37f, 0f, 200f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"ElderBark",
				new Tuple<int, int>(8, 0)
			},
			{
				"Feathers",
				new Tuple<int, int>(2, 0)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Chitin Arrow" },
			{ "catagory", "Arrows" },
			{ "prefab", "VAchitinarrow" },
			{ "sprite", "arrow_chitin" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(12f, 0f, 200f, item4: true)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(35f, 0f, 200f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(8, 0)
			},
			{
				"Chitin",
				new Tuple<int, int>(2, 0)
			},
			{
				"Feathers",
				new Tuple<int, int>(2, 0)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Wood Bolt" },
			{ "catagory", "Arrows" },
			{ "prefab", "VABoltWood" },
			{ "sprite", "bolt_wood" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(22f, 0f, 200f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>> { 
		{
			"Wood",
			new Tuple<int, int>(8, 0)
		} }, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Corewood Bolt" },
			{ "catagory", "Arrows" },
			{ "prefab", "VABoltCoreWood" },
			{ "sprite", "bolt_corewood" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(37f, 0f, 200f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"RoundLog",
				new Tuple<int, int>(8, 0)
			},
			{
				"Feathers",
				new Tuple<int, int>(2, 0)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Bronze Bolt" },
			{ "catagory", "Arrows" },
			{ "prefab", "VAbolt_bronze" },
			{ "sprite", "bronze_bolt" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(32f, 0f, 200f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(8, 0)
			},
			{
				"Bronze",
				new Tuple<int, int>(1, 0)
			},
			{
				"Feathers",
				new Tuple<int, int>(2, 0)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 1 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Poison Bolt" },
			{ "catagory", "Arrows" },
			{ "prefab", "VAbolt_poison" },
			{ "sprite", "poison_bolt" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
			},
			{
				"poison",
				new Tuple<float, float, float, bool>(52f, 0f, 200f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(26f, 0f, 200f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(8, 0)
			},
			{
				"Iron",
				new Tuple<int, int>(1, 0)
			},
			{
				"Feathers",
				new Tuple<int, int>(2, 0)
			},
			{
				"Ooze",
				new Tuple<int, int>(1, 0)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Obsidian Bolt" },
			{ "catagory", "Arrows" },
			{ "prefab", "VAObsidianBolt" },
			{ "sprite", "obsidian_bolt" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(52f, 0f, 200f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(8, 0)
			},
			{
				"Obsidian",
				new Tuple<int, int>(4, 0)
			},
			{
				"Feathers",
				new Tuple<int, int>(2, 0)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Frost Bolt" },
			{ "catagory", "Arrows" },
			{ "prefab", "VAbolt_frost" },
			{ "sprite", "ice_bolt" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
			},
			{
				"frost",
				new Tuple<float, float, float, bool>(52f, 0f, 200f, item4: true)
			},
			{
				"spirit",
				new Tuple<float, float, float, bool>(20f, 0f, 200f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(26f, 0f, 200f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(8, 0)
			},
			{
				"Silver",
				new Tuple<int, int>(1, 0)
			},
			{
				"Feathers",
				new Tuple<int, int>(2, 0)
			},
			{
				"FreezeGland",
				new Tuple<int, int>(1, 0)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 3 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Surtling Core Bolt" },
			{ "catagory", "Arrows" },
			{ "prefab", "VASurtlingBolt" },
			{ "sprite", "surtling_bolt" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(20f, 1f, 100f, item4: true)
			},
			{
				"fire",
				new Tuple<float, float, float, bool>(52f, 0f, 200f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(26f, 0f, 200f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(8, 0)
			},
			{
				"Iron",
				new Tuple<int, int>(1, 0)
			},
			{
				"Feathers",
				new Tuple<int, int>(2, 0)
			},
			{
				"SurtlingCore",
				new Tuple<int, int>(1, 0)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
	}

	private void LoadBows()
	{
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Blood Bone Bow" },
			{ "catagory", "Bows" },
			{ "prefab", "VABlood_bone_bow" },
			{ "sprite", "bone_bow" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(72f, 0f, 300f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(3f, 0f, 60f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(20f, 0f, 300f, item4: true)
			},
			{
				"draw_stamina_drain",
				new Tuple<float, float, float, bool>(4f, 1f, 50f, item4: true)
			},
			{
				"primary_attack_flat_health_cost",
				new Tuple<float, float, float, bool>(8f, 0f, 25f, item4: true)
			},
			{
				"primary_attack_percent_health_cost",
				new Tuple<float, float, float, bool>(0f, 0f, 50f, item4: true)
			},
			{
				"durability",
				new Tuple<float, float, float, bool>(200f, 0f, 500f, item4: true)
			},
			{
				"bow_draw_speed",
				new Tuple<float, float, float, bool>(100f, 1f, 300f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"ElderBark",
				new Tuple<int, int>(10, 5)
			},
			{
				"Silver",
				new Tuple<int, int>(10, 5)
			},
			{
				"BoneFragments",
				new Tuple<int, int>(20, 10)
			},
			{
				"TrophyUlv",
				new Tuple<int, int>(2, 0)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Bronze Arbelist" },
			{ "catagory", "Bows" },
			{ "prefab", "VAArbalistBronze" },
			{ "sprite", "bronze_crossbow_upright" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(105f, 0f, 300f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(200f, 0f, 300f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(3f, 0f, 60f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			},
			{
				"durability",
				new Tuple<float, float, float, bool>(100f, 0f, 300f, item4: true)
			},
			{
				"crossbow_reload_speed",
				new Tuple<float, float, float, bool>(100f, 1f, 300f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"ElderBark",
				new Tuple<int, int>(10, 5)
			},
			{
				"Bronze",
				new Tuple<int, int>(20, 10)
			},
			{
				"Guck",
				new Tuple<int, int>(10, 2)
			},
			{
				"DeerHide",
				new Tuple<int, int>(2, 2)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Eikthyrs Bow" },
			{ "catagory", "Bows" },
			{ "prefab", "VAAntler_Bow" },
			{ "sprite", "antler_bow" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(32f, 0f, 120f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"lightning",
				new Tuple<float, float, float, bool>(10f, 0f, 90f, item4: true)
			},
			{
				"lightning_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(5f, 0f, 50f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			},
			{
				"bow_draw_speed",
				new Tuple<float, float, float, bool>(100f, 1f, 300f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"FineWood",
				new Tuple<int, int>(15, 5)
			},
			{
				"Resin",
				new Tuple<int, int>(20, 10)
			},
			{
				"HardAntler",
				new Tuple<int, int>(3, 3)
			},
			{
				"TrophyEikthyr",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Bronze Crossbow" },
			{ "catagory", "Bows" },
			{ "prefab", "VACrossbowBronze" },
			{ "sprite", "bronze_crossbow2" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(80f, 0f, 300f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(3f, 0f, 60f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(150f, 0f, 300f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			},
			{
				"durability",
				new Tuple<float, float, float, bool>(100f, 0f, 300f, item4: true)
			},
			{
				"crossbow_reload_speed",
				new Tuple<float, float, float, bool>(100f, 1f, 300f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"FineWood",
				new Tuple<int, int>(10, 5)
			},
			{
				"RoundLog",
				new Tuple<int, int>(10, 5)
			},
			{
				"Bronze",
				new Tuple<int, int>(4, 0)
			},
			{
				"DeerHide",
				new Tuple<int, int>(2, 2)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Elders Reach" },
			{ "catagory", "Bows" },
			{ "prefab", "VACrossbowElder" },
			{ "sprite", "elder_crossbow" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(80f, 0f, 300f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"spirit",
				new Tuple<float, float, float, bool>(20f, 0f, 300f, item4: true)
			},
			{
				"spirit_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(3f, 0f, 60f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(150f, 0f, 300f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			},
			{
				"durability",
				new Tuple<float, float, float, bool>(100f, 0f, 300f, item4: true)
			},
			{
				"crossbow_reload_speed",
				new Tuple<float, float, float, bool>(100f, 1f, 300f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Bronze",
				new Tuple<int, int>(4, 2)
			},
			{
				"Stone",
				new Tuple<int, int>(20, 10)
			},
			{
				"CryptKey",
				new Tuple<int, int>(1, 1)
			},
			{
				"TrophyTheElder",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Moder Crossbow" },
			{ "catagory", "Bows" },
			{ "prefab", "VACrossbowModer" },
			{ "sprite", "moder_crossbow" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(150f, 0f, 300f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"frost",
				new Tuple<float, float, float, bool>(25f, 0f, 300f, item4: true)
			},
			{
				"frost_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(3f, 0f, 60f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(200f, 0f, 300f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			},
			{
				"durability",
				new Tuple<float, float, float, bool>(100f, 0f, 300f, item4: true)
			},
			{
				"crossbow_reload_speed",
				new Tuple<float, float, float, bool>(100f, 1f, 300f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"ElderBark",
				new Tuple<int, int>(10, 5)
			},
			{
				"Obsidian",
				new Tuple<int, int>(20, 10)
			},
			{
				"DragonTear",
				new Tuple<int, int>(10, 10)
			},
			{
				"TrophyDragonQueen",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Queens Greatbow" },
			{ "catagory", "Bows" },
			{ "prefab", "VAQueen_bow" },
			{ "sprite", "queen_bow" },
			{ "craftedAt", "blackforge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(72f, 0f, 200f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"poison",
				new Tuple<float, float, float, bool>(25f, 0f, 90f, item4: true)
			},
			{
				"poison_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"lightning",
				new Tuple<float, float, float, bool>(30f, 0f, 99f, item4: true)
			},
			{
				"lightning_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(25f, 0f, 50f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			},
			{
				"bow_draw_speed",
				new Tuple<float, float, float, bool>(100f, 1f, 300f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"YggdrasilWood",
				new Tuple<int, int>(10, 5)
			},
			{
				"Eitr",
				new Tuple<int, int>(20, 10)
			},
			{
				"JuteBlue",
				new Tuple<int, int>(4, 0)
			},
			{
				"TrophySeekerQueen",
				new Tuple<int, int>(1, 1)
			}
		});
	}

	private void LoadSwords()
	{
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Abyssal Sword" },
			{ "catagory", "Swords" },
			{ "prefab", "VASwordChitin" },
			{ "sprite", "chitin_sword" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(20f, 0f, 90f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(4f, 0f, 25f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(25f, 0f, 120f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(2f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(40f, 0f, 120f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(18f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(10f, 1f, 30f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"FineWood",
				new Tuple<int, int>(2, 1)
			},
			{
				"Chitin",
				new Tuple<int, int>(30, 15)
			},
			{
				"DeerHide",
				new Tuple<int, int>(2, 0)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Eikthyrs Sword" },
			{ "catagory", "Swords" },
			{ "prefab", "VAAntler_Sword" },
			{ "sprite", "antler_sword" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(20f, 0f, 90f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(2f, 0f, 20f, item4: true)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(10f, 0f, 90f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(4f, 0f, 20f, item4: true)
			},
			{
				"lightning",
				new Tuple<float, float, float, bool>(10f, 0f, 120f, item4: true)
			},
			{
				"lightning_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(40f, 0f, 120f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(8f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(8f, 1f, 30f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(16f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"FineWood",
				new Tuple<int, int>(3, 1)
			},
			{
				"Resin",
				new Tuple<int, int>(16, 8)
			},
			{
				"HardAntler",
				new Tuple<int, int>(3, 3)
			},
			{
				"TrophyEikthyr",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Elders Balance" },
			{ "catagory", "Swords" },
			{ "prefab", "VAVine_Sword" },
			{ "sprite", "vine_sword" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(35f, 0f, 90f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"spirit",
				new Tuple<float, float, float, bool>(20f, 0f, 120f, item4: true)
			},
			{
				"spirit_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(40f, 0f, 120f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(12f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(8f, 1f, 30f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(16f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Bronze",
				new Tuple<int, int>(2, 1)
			},
			{
				"Stone",
				new Tuple<int, int>(16, 8)
			},
			{
				"CryptKey",
				new Tuple<int, int>(1, 1)
			},
			{
				"TrophyTheElder",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Moders Grasp" },
			{ "catagory", "Swords" },
			{ "prefab", "VASwordModer" },
			{ "sprite", "moder_sword" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(35f, 0f, 90f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(2f, 0f, 20f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(30f, 0f, 90f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(4f, 0f, 20f, item4: true)
			},
			{
				"frost",
				new Tuple<float, float, float, bool>(25f, 0f, 120f, item4: true)
			},
			{
				"frost_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(40f, 0f, 120f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(30f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(12f, 1f, 30f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"ElderBark",
				new Tuple<int, int>(4, 2)
			},
			{
				"Obsidian",
				new Tuple<int, int>(30, 15)
			},
			{
				"DragonTear",
				new Tuple<int, int>(10, 10)
			},
			{
				"TrophyDragonQueen",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Bronze Greatsword" },
			{ "catagory", "Swords" },
			{ "prefab", "VAbronze_greatsword" },
			{ "sprite", "bronze_greatsword" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(50f, 0f, 200f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(22f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(12f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(4, 0)
			},
			{
				"Bronze",
				new Tuple<int, int>(20, 10)
			},
			{
				"DeerHide",
				new Tuple<int, int>(3, 0)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Iron Greatsword" },
			{ "catagory", "Swords" },
			{ "prefab", "VAiron_greatsword" },
			{ "sprite", "iron_greatsword" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(75f, 0f, 250f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(28f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(14f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(28f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"ElderBark",
				new Tuple<int, int>(15, 5)
			},
			{
				"Iron",
				new Tuple<int, int>(30, 15)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(4, 0)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Silver Greatsword" },
			{ "catagory", "Swords" },
			{ "prefab", "VAsilver_greatsword" },
			{ "sprite", "silver_greatsword" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(100f, 0f, 300f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
			},
			{
				"spirit",
				new Tuple<float, float, float, bool>(30f, 0f, 120f, item4: true)
			},
			{
				"spirit_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(40f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(16f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(32f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(10, 5)
			},
			{
				"Silver",
				new Tuple<int, int>(25, 10)
			},
			{
				"Iron",
				new Tuple<int, int>(4, 2)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(3, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Bonemasses Greatsword" },
			{ "catagory", "Swords" },
			{ "prefab", "VABonemassGreatsword" },
			{ "sprite", "bonemass_greatsword" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(75f, 0f, 250f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
			},
			{
				"poison",
				new Tuple<float, float, float, bool>(20f, 0f, 250f, item4: true)
			},
			{
				"poison_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(28f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(14f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(28f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"WitheredBone",
				new Tuple<int, int>(15, 5)
			},
			{
				"Iron",
				new Tuple<int, int>(30, 15)
			},
			{
				"Wishbone",
				new Tuple<int, int>(1, 1)
			},
			{
				"TrophyBonemass",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Yagluths Greatsword" },
			{ "catagory", "Swords" },
			{ "prefab", "VAYagluth_greatsword" },
			{ "sprite", "yagluth_greatsword" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(125f, 0f, 250f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
			},
			{
				"fire",
				new Tuple<float, float, float, bool>(25f, 0f, 250f, item4: true)
			},
			{
				"fire_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(49f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(18f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(36f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"BlackMetal",
				new Tuple<int, int>(10, 5)
			},
			{
				"Iron",
				new Tuple<int, int>(4, 2)
			},
			{
				"YagluthDrop",
				new Tuple<int, int>(2, 2)
			},
			{
				"TrophyGoblinKing",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Flint Sword" },
			{ "catagory", "Swords" },
			{ "prefab", "VAFlint_Sword" },
			{ "sprite", "flint_sword" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(15f, 0f, 90f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(40f, 0f, 120f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(4f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(6f, 1f, 30f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(12f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(2, 0)
			},
			{
				"Flint",
				new Tuple<int, int>(6, 3)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(0, 2)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Flint Greatsword" },
			{ "catagory", "Swords" },
			{ "prefab", "VAFlint_greatsword" },
			{ "sprite", "flint_greatsword" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(25f, 0f, 200f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(14f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(10f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(4, 0)
			},
			{
				"Flint",
				new Tuple<int, int>(9, 5)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(0, 2)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Queen Greatsword" },
			{ "catagory", "Swords" },
			{ "prefab", "VAQueen_greatsword" },
			{ "sprite", "queen_greatsword" },
			{ "craftedAt", "blackforge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(125f, 0f, 250f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
			},
			{
				"poison",
				new Tuple<float, float, float, bool>(25f, 0f, 250f, item4: true)
			},
			{
				"poison_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"lightning",
				new Tuple<float, float, float, bool>(30f, 0f, 99f, item4: true)
			},
			{
				"lightning_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(55f, 0f, 160f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(62f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(40f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"YggdrasilWood",
				new Tuple<int, int>(10, 5)
			},
			{
				"Eitr",
				new Tuple<int, int>(20, 10)
			},
			{
				"JuteBlue",
				new Tuple<int, int>(4, 2)
			},
			{
				"TrophySeekerQueen",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Queen Sword" },
			{ "catagory", "Swords" },
			{ "prefab", "VASwordQueen" },
			{ "sprite", "queen_sword" },
			{ "craftedAt", "blackforge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(95f, 0f, 250f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
			},
			{
				"poison",
				new Tuple<float, float, float, bool>(25f, 0f, 250f, item4: true)
			},
			{
				"poison_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"lightning",
				new Tuple<float, float, float, bool>(30f, 0f, 99f, item4: true)
			},
			{
				"lightning_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(40f, 0f, 160f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(52f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(16f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(32f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"YggdrasilWood",
				new Tuple<int, int>(3, 1)
			},
			{
				"Eitr",
				new Tuple<int, int>(10, 5)
			},
			{
				"JuteBlue",
				new Tuple<int, int>(3, 1)
			},
			{
				"TrophySeekerQueen",
				new Tuple<int, int>(1, 1)
			}
		});
	}

	private void LoadAxes()
	{
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Flint greataxe" },
			{ "catagory", "Axes" },
			{ "prefab", "VAFlint_greataxe" },
			{ "sprite", "flint_greataxe" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(25f, 0f, 200f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"chop",
				new Tuple<float, float, float, bool>(45f, 0f, 200f, item4: true)
			},
			{
				"chop_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(70f, 0f, 200f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(14f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(12f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(24f, 1f, 20f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(8, 0)
			},
			{
				"Flint",
				new Tuple<int, int>(9, 5)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(0, 2)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Bronze Lumber Axe" },
			{ "catagory", "Axes" },
			{ "prefab", "VAbronze_battleaxe" },
			{ "sprite", "bronze_battleaxe" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(50f, 0f, 200f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"chop",
				new Tuple<float, float, float, bool>(60f, 0f, 200f, item4: true)
			},
			{
				"chop_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(70f, 0f, 200f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(18f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(14f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(28f, 1f, 20f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"RoundLog",
				new Tuple<int, int>(20, 5)
			},
			{
				"Bronze",
				new Tuple<int, int>(10, 5)
			},
			{
				"DeerHide",
				new Tuple<int, int>(2, 0)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Eikthyrs Greataxe" },
			{ "catagory", "Axes" },
			{ "prefab", "VAAntler_greataxe" },
			{ "sprite", "antler_greataxe" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(10f, 0f, 200f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(20f, 0f, 200f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(2f, 0f, 25f, item4: true)
			},
			{
				"lightning",
				new Tuple<float, float, float, bool>(10f, 0f, 200f, item4: true)
			},
			{
				"lightning_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"chop",
				new Tuple<float, float, float, bool>(60f, 0f, 200f, item4: true)
			},
			{
				"chop_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(70f, 0f, 200f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(18f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(14f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(28f, 1f, 20f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"FineWood",
				new Tuple<int, int>(15, 0)
			},
			{
				"Resin",
				new Tuple<int, int>(30, 15)
			},
			{
				"HardAntler",
				new Tuple<int, int>(3, 3)
			},
			{
				"TrophyEikthyr",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Blackmetal Battleaxe" },
			{ "catagory", "Axes" },
			{ "prefab", "VAblackmetal_battleaxe" },
			{ "sprite", "blackmetal_battleaxe" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(120f, 0f, 300f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"chop",
				new Tuple<float, float, float, bool>(90f, 0f, 300f, item4: true)
			},
			{
				"chop_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"fire",
				new Tuple<float, float, float, bool>(20f, 0f, 160f, item4: true)
			},
			{
				"fire_per_level",
				new Tuple<float, float, float, bool>(0f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(70f, 0f, 200f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(49f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(40f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"FineWood",
				new Tuple<int, int>(10, 5)
			},
			{
				"BlackMetal",
				new Tuple<int, int>(35, 15)
			},
			{
				"LinenThread",
				new Tuple<int, int>(5, 0)
			},
			{
				"SurtlingCore",
				new Tuple<int, int>(4, 0)
			}
		});
	}

	private void LoadHammers()
	{
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Blackmetal Sledge" },
			{ "catagory", "Hammers" },
			{ "prefab", "VAblackmetal_sledge" },
			{ "sprite", "blackmetal_hammer" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(120f, 0f, 300f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"lightning",
				new Tuple<float, float, float, bool>(20f, 0f, 120f, item4: true)
			},
			{
				"lightning_per_level",
				new Tuple<float, float, float, bool>(0f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(49f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(40f, 1f, 50f, item4: true)
			},
			{
				"movement_speed",
				new Tuple<float, float, float, bool>(-20f, -30f, 0f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"FineWood",
				new Tuple<int, int>(10, 5)
			},
			{
				"BlackMetal",
				new Tuple<int, int>(30, 10)
			},
			{
				"LinenThread",
				new Tuple<int, int>(5, 0)
			},
			{
				"Thunderstone",
				new Tuple<int, int>(4, 0)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Elders Rock" },
			{ "catagory", "Hammers" },
			{ "prefab", "VAElderHammer" },
			{ "sprite", "elder_hammer" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(50f, 0f, 300f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"spirit",
				new Tuple<float, float, float, bool>(20f, 0f, 99f, item4: true)
			},
			{
				"spirit_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(22f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(12f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
			},
			{
				"movement_speed",
				new Tuple<float, float, float, bool>(-20f, -30f, 0f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Bronze",
				new Tuple<int, int>(4, 2)
			},
			{
				"Stone",
				new Tuple<int, int>(30, 15)
			},
			{
				"CryptKey",
				new Tuple<int, int>(1, 1)
			},
			{
				"TrophyTheElder",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Bonemasses Rage" },
			{ "catagory", "Hammers" },
			{ "prefab", "VABonemassWarhammer" },
			{ "sprite", "bonemass_warhammer" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(70f, 0f, 300f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"poison",
				new Tuple<float, float, float, bool>(20f, 0f, 99f, item4: true)
			},
			{
				"poison_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(100f, 0f, 400f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(31f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(14f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(28f, 1f, 50f, item4: true)
			},
			{
				"movement_speed",
				new Tuple<float, float, float, bool>(-20f, -30f, 0f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"WitheredBone",
				new Tuple<int, int>(10, 5)
			},
			{
				"Iron",
				new Tuple<int, int>(30, 10)
			},
			{
				"Wishbone",
				new Tuple<int, int>(1, 1)
			},
			{
				"TrophyBonemass",
				new Tuple<int, int>(1, 1)
			}
		});
	}

	private void LoadAtgeirs()
	{
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Flint Atgeir" },
			{ "catagory", "Atgeirs" },
			{ "prefab", "VAAtgeir_Flint" },
			{ "sprite", "flint_atgeir" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(25f, 0f, 90f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(30f, 0f, 120f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(11f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(10f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(10, 0)
			},
			{
				"Flint",
				new Tuple<int, int>(6, 3)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(0, 2)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Eikthyrs Atgeir" },
			{ "catagory", "Atgeirs" },
			{ "prefab", "VAatgeir_antler" },
			{ "sprite", "antler_atgeir" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(35f, 0f, 90f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
			},
			{
				"lightning",
				new Tuple<float, float, float, bool>(10f, 0f, 25f, item4: true)
			},
			{
				"lightning_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(30f, 0f, 120f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(14f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(12f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"FineWood",
				new Tuple<int, int>(15, 0)
			},
			{
				"Resin",
				new Tuple<int, int>(30, 15)
			},
			{
				"HardAntler",
				new Tuple<int, int>(3, 3)
			},
			{
				"TrophyEikthyr",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Abyssal Atgeir" },
			{ "catagory", "Atgeirs" },
			{ "prefab", "VAAtgeirchitin" },
			{ "sprite", "chitin_heavy_atgeir_small2" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(35f, 0f, 140f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(2f, 0f, 25f, item4: true)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(20f, 0f, 120f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(4f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(30f, 0f, 120f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(21f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(14f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(28f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"FineWood",
				new Tuple<int, int>(10, 0)
			},
			{
				"Chitin",
				new Tuple<int, int>(30, 15)
			},
			{
				"DeerHide",
				new Tuple<int, int>(2, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Silver Atgeir" },
			{ "catagory", "Atgeirs" },
			{ "prefab", "VASilverAtgeir" },
			{ "sprite", "silver_atgeir" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(75f, 0f, 250f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
			},
			{
				"spirit",
				new Tuple<float, float, float, bool>(30f, 0f, 120f, item4: true)
			},
			{
				"spirit_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(30f, 0f, 120f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(39f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(16f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(32f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(10, 0)
			},
			{
				"Silver",
				new Tuple<int, int>(25, 10)
			},
			{
				"Iron",
				new Tuple<int, int>(4, 2)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(3, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Yagluths Reach" },
			{ "catagory", "Atgeirs" },
			{ "prefab", "VAYagluthAtgeir" },
			{ "sprite", "yagluth_atgeir" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(105f, 0f, 250f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 25f, item4: true)
			},
			{
				"fire",
				new Tuple<float, float, float, bool>(25f, 0f, 120f, item4: true)
			},
			{
				"fire_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(30f, 0f, 120f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(52f, 0f, 120f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(18f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(36f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"BlackMetal",
				new Tuple<int, int>(10, 0)
			},
			{
				"Iron",
				new Tuple<int, int>(4, 2)
			},
			{
				"YagluthDrop",
				new Tuple<int, int>(2, 2)
			},
			{
				"TrophyGoblinKing",
				new Tuple<int, int>(1, 1)
			}
		});
	}

	private void LoadShields()
	{
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Serpent Scale Buckler" },
			{ "catagory", "Shields" },
			{ "prefab", "VAserpent_buckler" },
			{ "sprite", "serpentscale_shield2" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(48f, 0f, 120f, item4: true)
			},
			{
				"block_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"deflection_force",
				new Tuple<float, float, float, bool>(40f, 0f, 120f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool> { { "resistPierce", true } }, new Dictionary<string, Tuple<int, int>>
		{
			{
				"FineWood",
				new Tuple<int, int>(8, 8)
			},
			{
				"Iron",
				new Tuple<int, int>(2, 2)
			},
			{
				"SerpentScale",
				new Tuple<int, int>(6, 3)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Elders Bulwark" },
			{ "catagory", "Shields" },
			{ "prefab", "VAElderRoundShield" },
			{ "sprite", "elder_roundshield" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(28f, 0f, 120f, item4: true)
			},
			{
				"block_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"deflection_force",
				new Tuple<float, float, float, bool>(30f, 0f, 120f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool> { { "veryResistBlunt", true } }, new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(16, 8)
			},
			{
				"Bronze",
				new Tuple<int, int>(8, 4)
			},
			{
				"CryptKey",
				new Tuple<int, int>(1, 1)
			},
			{
				"TrophyTheElder",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Moders Roundshield" },
			{ "catagory", "Shields" },
			{ "prefab", "VAModer_RoundShield" },
			{ "sprite", "moder_roundshield" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(62f, 0f, 120f, item4: true)
			},
			{
				"block_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"deflection_force",
				new Tuple<float, float, float, bool>(40f, 0f, 120f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(20f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool> { { "veryResistFrost", true } }, new Dictionary<string, Tuple<int, int>>
		{
			{
				"FineWood",
				new Tuple<int, int>(24, 12)
			},
			{
				"Silver",
				new Tuple<int, int>(16, 8)
			},
			{
				"DragonTear",
				new Tuple<int, int>(10, 10)
			},
			{
				"TrophyDragonQueen",
				new Tuple<int, int>(1, 1)
			}
		});
	}

	private void LoadDaggers()
	{
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Flint Daggers" },
			{ "catagory", "Daggers" },
			{ "prefab", "VADagger_Flint_2h" },
			{ "sprite", "flint_2h_dagger" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(4f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(12f, 0f, 99f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(12f, 0f, 99f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(10f, 0f, 40f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(4f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(12f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(4, 0)
			},
			{
				"Flint",
				new Tuple<int, int>(6, 3)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(2, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Eikthyrs Dagger" },
			{ "catagory", "Daggers" },
			{ "prefab", "VAAntler_dagger" },
			{ "sprite", "antler_dagger" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(2f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(10f, 0f, 99f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(10f, 0f, 99f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"lightning",
				new Tuple<float, float, float, bool>(7f, 0f, 99f, item4: true)
			},
			{
				"lightning_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(10f, 0f, 30f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(6f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(18f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"FineWood",
				new Tuple<int, int>(3, 0)
			},
			{
				"Resin",
				new Tuple<int, int>(16, 8)
			},
			{
				"HardAntler",
				new Tuple<int, int>(3, 3)
			},
			{
				"TrophyEikthyr",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Rascals Daggers" },
			{ "catagory", "Daggers" },
			{ "prefab", "VAdagger_bronze_2h" },
			{ "sprite", "bronze_dagger_2h" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(8f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(20f, 0f, 99f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(20f, 0f, 99f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(10f, 0f, 40f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(6f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(18f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"RoundLog",
				new Tuple<int, int>(4, 0)
			},
			{
				"Bronze",
				new Tuple<int, int>(8, 4)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(4, 2)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Bronze Dagger" },
			{ "catagory", "Daggers" },
			{ "prefab", "VAdagger_bronze" },
			{ "sprite", "bronze_dagger" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(2f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(16f, 0f, 99f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(16f, 0f, 99f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(10f, 0f, 30f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(6f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(18f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"RoundLog",
				new Tuple<int, int>(2, 0)
			},
			{
				"Bronze",
				new Tuple<int, int>(6, 3)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(3, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Rogue Daggers" },
			{ "catagory", "Daggers" },
			{ "prefab", "VAdagger_iron_2h" },
			{ "sprite", "iron_dagger_2h" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(12f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(25f, 0f, 99f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(25f, 0f, 99f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(10f, 0f, 40f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(8f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(4, 2)
			},
			{
				"Iron",
				new Tuple<int, int>(16, 8)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(6, 3)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Iron Dagger" },
			{ "catagory", "Daggers" },
			{ "prefab", "VAdagger_iron" },
			{ "sprite", "iron_dagger" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(2f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(22f, 0f, 99f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(22f, 0f, 99f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(10f, 0f, 30f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(8f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool> { { "enabled", true } }, new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(2, 1)
			},
			{
				"Iron",
				new Tuple<int, int>(12, 6)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(4, 2)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Blackguards Runic Daggers" },
			{ "catagory", "Daggers" },
			{ "prefab", "VAdagger_silver_2h" },
			{ "sprite", "silver_dagger_2h" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(16f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(34f, 0f, 99f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(34f, 0f, 99f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"spirit",
				new Tuple<float, float, float, bool>(12f, 0f, 99f, item4: true)
			},
			{
				"spirit_per_level",
				new Tuple<float, float, float, bool>(0f, 0f, 25f, item4: true)
			},
			{
				"frost",
				new Tuple<float, float, float, bool>(0f, 0f, 99f, item4: true)
			},
			{
				"frost_per_level",
				new Tuple<float, float, float, bool>(0f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(10f, 0f, 40f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(10f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(30f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(4, 2)
			},
			{
				"Silver",
				new Tuple<int, int>(12, 6)
			},
			{
				"Iron",
				new Tuple<int, int>(4, 2)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(6, 3)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Silver Dagger" },
			{ "catagory", "Daggers" },
			{ "prefab", "VAdagger_silver" },
			{ "sprite", "silver_dagger" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(2f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(34f, 0f, 99f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(34f, 0f, 99f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"spirit",
				new Tuple<float, float, float, bool>(0f, 0f, 99f, item4: true)
			},
			{
				"spirit_per_level",
				new Tuple<float, float, float, bool>(0f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(10f, 0f, 30f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(10f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(30f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>
		{
			{ "enabled", true },
			{ "craftable", false }
		}, new Dictionary<string, Tuple<int, int>>
		{
			{
				"ElderBark",
				new Tuple<int, int>(4, 2)
			},
			{
				"Obsidian",
				new Tuple<int, int>(12, 5)
			},
			{
				"Silver",
				new Tuple<int, int>(14, 6)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Moders Dagger" },
			{ "catagory", "Daggers" },
			{ "prefab", "VAdagger_moder" },
			{ "sprite", "moder_dagger" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(2f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(34f, 0f, 99f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(34f, 0f, 99f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"spirit",
				new Tuple<float, float, float, bool>(0f, 0f, 99f, item4: true)
			},
			{
				"spirit_per_level",
				new Tuple<float, float, float, bool>(0f, 0f, 25f, item4: true)
			},
			{
				"frost",
				new Tuple<float, float, float, bool>(18f, 0f, 99f, item4: true)
			},
			{
				"frost_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(10f, 0f, 30f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(10f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(30f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool> { { "enabled", true } }, new Dictionary<string, Tuple<int, int>>
		{
			{
				"ElderBark",
				new Tuple<int, int>(4, 2)
			},
			{
				"Obsidian",
				new Tuple<int, int>(15, 5)
			},
			{
				"DragonTear",
				new Tuple<int, int>(10, 10)
			},
			{
				"TrophyDragonQueen",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Bonemasses Dagger" },
			{ "catagory", "Daggers" },
			{ "prefab", "VABonemassDagger" },
			{ "sprite", "bonemass_dagger" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(2f, 0f, 48f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(22f, 0f, 99f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(22f, 0f, 99f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"poison",
				new Tuple<float, float, float, bool>(10f, 0f, 99f, item4: true)
			},
			{
				"poison_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(10f, 0f, 30f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(8f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(24f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool> { { "enabled", true } }, new Dictionary<string, Tuple<int, int>>
		{
			{
				"WitheredBone",
				new Tuple<int, int>(2, 1)
			},
			{
				"Iron",
				new Tuple<int, int>(12, 6)
			},
			{
				"Wishbone",
				new Tuple<int, int>(1, 1)
			},
			{
				"TrophyBonemass",
				new Tuple<int, int>(1, 1)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Queens Dagger" },
			{ "catagory", "Daggers" },
			{ "prefab", "VAdagger_queen" },
			{ "sprite", "dagger_queen" },
			{ "craftedAt", "blackforge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(2f, 0f, 48f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(34f, 0f, 99f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(34f, 0f, 99f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(1f, 0f, 25f, item4: true)
			},
			{
				"poison",
				new Tuple<float, float, float, bool>(18f, 0f, 99f, item4: true)
			},
			{
				"poison_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"lightning",
				new Tuple<float, float, float, bool>(18f, 0f, 99f, item4: true)
			},
			{
				"lightning_per_level",
				new Tuple<float, float, float, bool>(3f, 0f, 25f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(10f, 0f, 30f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(14f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(42f, 1f, 80f, item4: true)
			}
		}, new Dictionary<string, bool> { { "enabled", true } }, new Dictionary<string, Tuple<int, int>>
		{
			{
				"YggdrasilWood",
				new Tuple<int, int>(2, 1)
			},
			{
				"Eitr",
				new Tuple<int, int>(10, 5)
			},
			{
				"JuteBlue",
				new Tuple<int, int>(2, 0)
			},
			{
				"TrophySeekerQueen",
				new Tuple<int, int>(1, 1)
			}
		});
	}

	private void LoadSpears()
	{
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Moders Strike" },
			{ "catagory", "Spears" },
			{ "prefab", "VASpearModer" },
			{ "sprite", "moder_spear" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(30f, 0f, 48f, item4: true)
			},
			{
				"pierce",
				new Tuple<float, float, float, bool>(45f, 0f, 120f, item4: true)
			},
			{
				"pierce_per_level",
				new Tuple<float, float, float, bool>(2f, 0f, 20f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(30f, 0f, 99f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(4f, 0f, 20f, item4: true)
			},
			{
				"frost",
				new Tuple<float, float, float, bool>(25f, 0f, 99f, item4: true)
			},
			{
				"frost_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(20f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(12f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(14f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"ElderBark",
				new Tuple<int, int>(15, 10)
			},
			{
				"Obsidian",
				new Tuple<int, int>(8, 4)
			},
			{
				"DragonTear",
				new Tuple<int, int>(10, 10)
			},
			{
				"TrophyDragonQueen",
				new Tuple<int, int>(1, 1)
			}
		});
	}

	private void LoadFists()
	{
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Flint knuckles" },
			{ "catagory", "Fists" },
			{ "prefab", "VAFist_Flint" },
			{ "sprite", "flint_fists" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(5f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(6f, 0f, 120f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(4f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(20f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(4f, 1f, 20f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(4, 0)
			},
			{
				"Flint",
				new Tuple<int, int>(4, 2)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(2, 2)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Bronze knuckles" },
			{ "catagory", "Fists" },
			{ "prefab", "VAFist_Bronze" },
			{ "sprite", "bronze_fists" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(5f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(20f, 0f, 120f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(4f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(20f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(6f, 1f, 20f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"RoundLog",
				new Tuple<int, int>(4, 0)
			},
			{
				"Bronze",
				new Tuple<int, int>(6, 3)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(4, 4)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Iron knuckles" },
			{ "catagory", "Fists" },
			{ "prefab", "VAFist_Iron" },
			{ "sprite", "iron_fists" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(5f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(35f, 0f, 120f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(4f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(20f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(8f, 1f, 20f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Wood",
				new Tuple<int, int>(4, 2)
			},
			{
				"Iron",
				new Tuple<int, int>(12, 6)
			},
			{
				"LeatherScraps",
				new Tuple<int, int>(6, 6)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Goblin king knuckles" },
			{ "catagory", "Fists" },
			{ "prefab", "VAFist_Yagluth" },
			{ "sprite", "yagluth_fists" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(5f, 0f, 48f, item4: true)
			},
			{
				"slash",
				new Tuple<float, float, float, bool>(80f, 0f, 120f, item4: true)
			},
			{
				"slash_per_level",
				new Tuple<float, float, float, bool>(4f, 0f, 20f, item4: true)
			},
			{
				"fire",
				new Tuple<float, float, float, bool>(25f, 0f, 120f, item4: true)
			},
			{
				"fire_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(20f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(12f, 1f, 20f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(36f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"BlackMetal",
				new Tuple<int, int>(4, 2)
			},
			{
				"Iron",
				new Tuple<int, int>(6, 3)
			},
			{
				"YagluthDrop",
				new Tuple<int, int>(2, 2)
			},
			{
				"TrophyGoblinKing",
				new Tuple<int, int>(1, 1)
			}
		});
	}

	private void LoadMaces()
	{
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Elders Fist" },
			{ "catagory", "Maces" },
			{ "prefab", "VAElder_mace" },
			{ "sprite", "elder_mace" },
			{ "craftedAt", "forge" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(35f, 0f, 90f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"spirit",
				new Tuple<float, float, float, bool>(20f, 0f, 120f, item4: true)
			},
			{
				"spirit_per_level",
				new Tuple<float, float, float, bool>(5f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(80f, 0f, 120f, item4: true)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(12f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(8f, 1f, 30f, item4: true)
			},
			{
				"secondary_attack_stamina",
				new Tuple<float, float, float, bool>(16f, 1f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"Bronze",
				new Tuple<int, int>(2, 1)
			},
			{
				"Stone",
				new Tuple<int, int>(16, 8)
			},
			{
				"CryptKey",
				new Tuple<int, int>(1, 1)
			},
			{
				"TrophyTheElder",
				new Tuple<int, int>(1, 1)
			}
		});
	}

	private void LoadMagic()
	{
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Staff of poison" },
			{ "catagory", "Magics" },
			{ "prefab", "VAStaff_Poison" },
			{ "sprite", "poison_staff" },
			{ "craftedAt", "piece_magetable" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(48f, 0f, 90f, item4: true)
			},
			{
				"poison",
				new Tuple<float, float, float, bool>(120f, 0f, 200f, item4: true)
			},
			{
				"poison_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(120f, 0f, 200f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(0f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(20f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_eitr",
				new Tuple<float, float, float, bool>(35f, 0f, 50f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(0f, 0f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"YggdrasilWood",
				new Tuple<int, int>(20, 10)
			},
			{
				"Guck",
				new Tuple<int, int>(4, 2)
			},
			{
				"Eitr",
				new Tuple<int, int>(16, 8)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Staff of Spirit" },
			{ "catagory", "Magics" },
			{ "prefab", "VAStaff_Spirit" },
			{ "sprite", "spirit_staff" },
			{ "craftedAt", "piece_magetable" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(48f, 0f, 90f, item4: true)
			},
			{
				"spirit",
				new Tuple<float, float, float, bool>(120f, 0f, 200f, item4: true)
			},
			{
				"spirit_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(120f, 0f, 200f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(0f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(20f, 0f, 60f, item4: true)
			},
			{
				"primary_attack_eitr",
				new Tuple<float, float, float, bool>(35f, 0f, 50f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(0f, 0f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"YggdrasilWood",
				new Tuple<int, int>(20, 10)
			},
			{
				"GreydwarfEye",
				new Tuple<int, int>(4, 2)
			},
			{
				"Eitr",
				new Tuple<int, int>(16, 8)
			}
		});
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Druidic Staff of Poison" },
			{ "catagory", "Magics" },
			{ "prefab", "VAStaff_Druid_Poison" },
			{ "sprite", "poison_staff_druidic" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(24f, 0f, 48f, item4: true)
			},
			{
				"poison",
				new Tuple<float, float, float, bool>(50f, 0f, 120f, item4: true)
			},
			{
				"poison_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(50f, 0f, 200f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(0f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(20f, 0f, 60f, item4: true)
			},
			{
				"durability",
				new Tuple<float, float, float, bool>(50f, 0f, 500f, item4: true)
			},
			{
				"durability_per_level",
				new Tuple<float, float, float, bool>(10f, 0f, 75f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(35f, 0f, 50f, item4: true)
			},
			{
				"primary_attack_eitr",
				new Tuple<float, float, float, bool>(0f, 0f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"ElderBark",
				new Tuple<int, int>(20, 10)
			},
			{
				"Guck",
				new Tuple<int, int>(4, 2)
			},
			{
				"TrophyBlob",
				new Tuple<int, int>(2, 1)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Druidic Staff of Spirit" },
			{ "catagory", "Magics" },
			{ "prefab", "VAStaff_Druid_Spirit" },
			{ "sprite", "spirit_staff_druid" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(24f, 0f, 48f, item4: true)
			},
			{
				"spirit",
				new Tuple<float, float, float, bool>(50f, 0f, 120f, item4: true)
			},
			{
				"spirit_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(50f, 0f, 200f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(0f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(20f, 0f, 60f, item4: true)
			},
			{
				"durability",
				new Tuple<float, float, float, bool>(50f, 0f, 500f, item4: true)
			},
			{
				"durability_per_level",
				new Tuple<float, float, float, bool>(10f, 0f, 75f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(35f, 0f, 50f, item4: true)
			},
			{
				"primary_attack_eitr",
				new Tuple<float, float, float, bool>(0f, 0f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"ElderBark",
				new Tuple<int, int>(20, 10)
			},
			{
				"GreydwarfEye",
				new Tuple<int, int>(4, 2)
			},
			{
				"TrophyGreydwarfShaman",
				new Tuple<int, int>(2, 1)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Druidic Staff of Ice" },
			{ "catagory", "Magics" },
			{ "prefab", "VAStaff_Druid_Ice" },
			{ "sprite", "ice_staff_druidic" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(24f, 0f, 48f, item4: true)
			},
			{
				"frost",
				new Tuple<float, float, float, bool>(12f, 0f, 120f, item4: true)
			},
			{
				"frost_per_level",
				new Tuple<float, float, float, bool>(2f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(20f, 0f, 60f, item4: true)
			},
			{
				"durability",
				new Tuple<float, float, float, bool>(50f, 0f, 500f, item4: true)
			},
			{
				"durability_per_level",
				new Tuple<float, float, float, bool>(10f, 0f, 75f, item4: true)
			},
			{
				"primary_attack_stamina",
				new Tuple<float, float, float, bool>(5f, 0f, 50f, item4: true)
			},
			{
				"primary_attack_eitr",
				new Tuple<float, float, float, bool>(0f, 0f, 50f, item4: true)
			}
		}, new Dictionary<string, bool>(), new Dictionary<string, Tuple<int, int>>
		{
			{
				"ElderBark",
				new Tuple<int, int>(20, 10)
			},
			{
				"FreezeGland",
				new Tuple<int, int>(4, 2)
			},
			{
				"TrophyHatchling",
				new Tuple<int, int>(2, 1)
			}
		}, new Dictionary<string, int> { { "stationRequiredLevel", 2 } });
		new ValArmoryItem(EmbeddedResourceBundle, new Dictionary<string, string>
		{
			{ "name", "Druidic Staff of Fire" },
			{ "catagory", "Magics" },
			{ "prefab", "VAStaff_Druid_Fire" },
			{ "sprite", "fire_staff_druidic" },
			{ "craftedAt", "piece_workbench" }
		}, new Dictionary<string, Tuple<float, float, float, bool>>
		{
			{
				"amount",
				new Tuple<float, float, float, bool>(1f, 1f, 1f, item4: false)
			},
			{
				"block",
				new Tuple<float, float, float, bool>(24f, 0f, 48f, item4: true)
			},
			{
				"fire",
				new Tuple<float, float, float, bool>(50f, 0f, 120f, item4: true)
			},
			{
				"fire_per_level",
				new Tuple<float, float, float, bool>(6f, 0f, 20f, item4: true)
			},
			{
				"blunt",
				new Tuple<float, float, float, bool>(50f, 0f, 200f, item4: true)
			},
			{
				"blunt_per_level",
				new Tuple<float, float, float, bool>(0f, 0f, 20f, item4: true)
			},
			{
				"attack_force",
				new Tuple<float, float, float, bool>(20f, 0f, 60f, item4: true)
			},