context: #region Header
  // **********
  // ServUO - Loot.cs
  // **********
  #endregion
  
  #region References
  using System;
  
  using Server.Items;
  #endregion
  
  namespace Server
  {
  	public class Loot
  	{
  		#region List definitions
  
  		#region SA
  		private static readonly Type[] m_SAWeaponTypes = new[]
  		{
  			typeof(DiscMace), typeof(GargishTalwar), typeof(Shortblade), typeof(DualPointedSpear), typeof(GlassStaff),
  			typeof(StoneWarSword), typeof(DualShortAxes), typeof(GlassSword), typeof(GargishDagger)
  		};
  
  		public static Type[] SAWeaponTypes { get { return m_SAWeaponTypes; } }
  
  		private static readonly Type[] m_SARangedWeaponTypes = new[] { typeof(Boomerang), typeof(Cyclone), typeof(SoulGlaive), };
  
  		public static Type[] SARangedWeaponTypes { get { return m_SARangedWeaponTypes; } }
  
  		private static readonly Type[] m_SAArmorTypes = new[]
  		{
  			typeof(GargishLeatherChest), typeof(GargishLeatherLegs), typeof(GargishLeatherArms), typeof(GargishLeatherKilt),
  			typeof(GargishLeatherWingArmor), typeof(GargishStoneChest), typeof(GargishStoneLegs), typeof(GargishStoneArms),
  			typeof(GargishStoneKilt), typeof(GargishPlateChest), typeof(GargishPlateLegs), typeof(GargishPlateArms),
  			typeof(GargishPlateKilt)
  		};
  
  		public static Type[] SAArmorTypes { get { return m_SAArmorTypes; } }
  
  		private static readonly Type[] m_SAClothingTypes = new[]
  		{
  			typeof(GargishClothChest), typeof(GargishClothArms), typeof(GargishClothKilt), typeof(GargishClothLegs),
  			typeof(GargishClothWingArmor)
  		};
  
  		public static Type[] SAClothingTypes { get { return m_SAClothingTypes; } }
  		#endregion
  
  		#region Mondain's Legacy
  		private static readonly Type[] m_MLWeaponTypes = new[]
  		{
  			typeof(AssassinSpike), typeof(DiamondMace), typeof(ElvenMachete), typeof(ElvenSpellblade), typeof(Leafblade),
  			typeof(OrnateAxe), typeof(RadiantScimitar), typeof(RuneBlade), typeof(WarCleaver), typeof(WildStaff)
  		};
  
  		public static Type[] MLWeaponTypes { get { return m_MLWeaponTypes; } }
  
  		private static readonly Type[] m_MLRangedWeaponTypes = new[] { typeof(ElvenCompositeLongbow), typeof(MagicalShortbow) };
  
  		public static Type[] MLRangedWeaponTypes { get { return m_MLRangedWeaponTypes; } }
  
  		private static readonly Type[] m_MLArmorTypes = new[]
  		{
  			typeof(Circlet), typeof(GemmedCirclet), typeof(LeafTonlet), typeof(RavenHelm), typeof(RoyalCirclet),
  			typeof(VultureHelm), typeof(WingedHelm), typeof(LeafArms), typeof(LeafChest), typeof(LeafGloves), typeof(LeafGorget),
  			typeof(LeafLegs), typeof(WoodlandArms), typeof(WoodlandChest), typeof(WoodlandGloves), typeof(WoodlandGorget),
  			typeof(WoodlandLegs), typeof(HideChest), typeof(HideGloves), typeof(HideGorget), typeof(HidePants),
  			typeof(HidePauldrons)
  		};
  
  		public static Type[] MLArmorTypes { get { return m_MLArmorTypes; } }
  
  		private static readonly Type[] m_MLClothingTypes = new[]
  		{
  			typeof(MaleElvenRobe), typeof(FemaleElvenRobe), typeof(ElvenPants), typeof(ElvenShirt), typeof(ElvenDarkShirt),
  			typeof(ElvenBoots), typeof(VultureHelm), typeof(WoodlandBelt)
  		};
  
  		public static Type[] MLClothingTypes { get { return m_MLClothingTypes; } }
  		#endregion
  
  		private static readonly Type[] m_SEWeaponTypes = new[]
  		{
  			typeof(Bokuto), typeof(Daisho), typeof(Kama), typeof(Lajatang), typeof(NoDachi), typeof(Nunchaku), typeof(Sai),
  			typeof(Tekagi), typeof(Tessen), typeof(Tetsubo), typeof(Wakizashi)
  		};
  
  		public static Type[] SEWeaponTypes { get { return m_SEWeaponTypes; } }
  
  		private static readonly Type[] m_AosWeaponTypes = new[]
  		{
  			typeof(Scythe), typeof(BoneHarvester), typeof(Scepter), typeof(BladedStaff), typeof(Pike), typeof(DoubleBladedStaff),
  			typeof(Lance), typeof(CrescentBlade)
  		};
  
  		public static Type[] AosWeaponTypes { get { return m_AosWeaponTypes; } }
  
  		private static readonly Type[] m_WeaponTypes = new[]
  		{
  			typeof(Axe), typeof(BattleAxe), typeof(DoubleAxe), typeof(ExecutionersAxe), typeof(Hatchet), typeof(LargeBattleAxe),
  			typeof(TwoHandedAxe), typeof(WarAxe), typeof(Club), typeof(Mace), typeof(Maul), typeof(WarHammer), typeof(WarMace),
  			typeof(Bardiche), typeof(Halberd), typeof(Spear), typeof(ShortSpear), typeof(Pitchfork), typeof(WarFork),
  			typeof(BlackStaff), typeof(GnarledStaff), typeof(QuarterStaff), typeof(Broadsword), typeof(Cutlass), typeof(Katana),
  			typeof(Kryss), typeof(Longsword), typeof(Scimitar), typeof(VikingSword), typeof(Pickaxe), typeof(HammerPick),
  			typeof(ButcherKnife), typeof(Cleaver), typeof(Dagger), typeof(SkinningKnife), typeof(ShepherdsCrook)
  		};
  
  		public static Type[] WeaponTypes { get { return m_WeaponTypes; } }
  
  		private static readonly Type[] m_SERangedWeaponTypes = new[] { typeof(Yumi) };
  
  		public static Type[] SERangedWeaponTypes { get { return m_SERangedWeaponTypes; } }
  
  		private static readonly Type[] m_AosRangedWeaponTypes = new[] { typeof(CompositeBow), typeof(RepeatingCrossbow) };
  
  		public static Type[] AosRangedWeaponTypes { get { return m_AosRangedWeaponTypes; } }
  
  		private static readonly Type[] m_RangedWeaponTypes = new[] { typeof(Bow), typeof(Crossbow), typeof(HeavyCrossbow) };
  
  		public static Type[] RangedWeaponTypes { get { return m_RangedWeaponTypes; } }
  
  		private static readonly Type[] m_SEArmorTypes = new[]
  		{
  			typeof(ChainHatsuburi), typeof(LeatherDo), typeof(LeatherHaidate), typeof(LeatherHiroSode), typeof(LeatherJingasa),
  			typeof(LeatherMempo), typeof(LeatherNinjaHood), typeof(LeatherNinjaJacket), typeof(LeatherNinjaMitts),
  			typeof(LeatherNinjaPants), typeof(LeatherSuneate), typeof(DecorativePlateKabuto), typeof(HeavyPlateJingasa),
  			typeof(LightPlateJingasa), typeof(PlateBattleKabuto), typeof(PlateDo), typeof(PlateHaidate), typeof(PlateHatsuburi),
  			typeof(PlateHiroSode), typeof(PlateMempo), typeof(PlateSuneate), typeof(SmallPlateJingasa),
  			typeof(StandardPlateKabuto), typeof(StuddedDo), typeof(StuddedHaidate), typeof(StuddedHiroSode), typeof(StuddedMempo)
  			, typeof(StuddedSuneate)
  		};
  
  		public static Type[] SEArmorTypes { get { return m_SEArmorTypes; } }
  
  		private static readonly Type[] m_ArmorTypes = new[]
  		{
  			typeof(BoneArms), typeof(BoneChest), typeof(BoneGloves), typeof(BoneLegs), typeof(BoneHelm), typeof(ChainChest),
  			typeof(ChainLegs), typeof(ChainCoif), typeof(Bascinet), typeof(CloseHelm), typeof(Helmet), typeof(NorseHelm),
  			typeof(OrcHelm), typeof(FemaleLeatherChest), typeof(LeatherArms), typeof(LeatherBustierArms), typeof(LeatherChest),
  			typeof(LeatherGloves), typeof(LeatherGorget), typeof(LeatherLegs), typeof(LeatherShorts), typeof(LeatherSkirt),
  			typeof(LeatherCap), typeof(FemalePlateChest), typeof(PlateArms), typeof(PlateChest), typeof(PlateGloves),
  			typeof(PlateGorget), typeof(PlateHelm), typeof(PlateLegs), typeof(RingmailArms), typeof(RingmailChest),
  			typeof(RingmailGloves), typeof(RingmailLegs), typeof(FemaleStuddedChest), typeof(StuddedArms),
  			typeof(StuddedBustierArms), typeof(StuddedChest), typeof(StuddedGloves), typeof(StuddedGorget), typeof(StuddedLegs)
  		};
  
  		public static Type[] ArmorTypes { get { return m_ArmorTypes; } }
  
  		private static readonly Type[] m_AosShieldTypes = new[] { typeof(ChaosShield), typeof(OrderShield) };
  
  		public static Type[] AosShieldTypes { get { return m_AosShieldTypes; } }
  
  		private static readonly Type[] m_ShieldTypes = new[]
  		{
  			typeof(BronzeShield), typeof(Buckler), typeof(HeaterShield), typeof(MetalShield), typeof(MetalKiteShield),
  			typeof(WoodenKiteShield), typeof(WoodenShield), typeof(GargishWoodenShield), typeof(GargishKiteShield),
  			typeof(LargeStoneShield), typeof(LargePlateShield)
  		};
  
  		public static Type[] ShieldTypes { get { return m_ShieldTypes; } }
  
  		private static readonly Type[] m_GemTypes = new[]
  		{
  			typeof(Amber), typeof(Amethyst), typeof(Citrine), typeof(Diamond), typeof(Emerald), typeof(Ruby), typeof(Sapphire),
  			typeof(StarSapphire), typeof(Tourmaline)
  		};
  
  		public static Type[] GemTypes { get { return m_GemTypes; } }
  
  		private static readonly Type[] m_JewelryTypes = new[]
  		{
  			typeof(GoldRing), typeof(GoldBracelet), typeof (GoldNecklace), typeof (GoldEarrings),
              typeof(SilverRing), typeof(SilverBracelet), typeof (SilverNecklace), typeof (SilverEarrings),
              typeof(GargishRing), typeof(GargishBracelet), typeof(GargishNecklace), typeof(GargishEarrings)
  		};
  
  		public static Type[] JewelryTypes { get { return m_JewelryTypes; } }
  
  		private static readonly Type[] m_RegTypes = new[]
  		{
  			typeof(BlackPearl), typeof(Bloodmoss), typeof(Garlic), typeof(Ginseng), typeof(MandrakeRoot), typeof(Nightshade),
  			typeof(SulfurousAsh), typeof(SpidersSilk)
  		};
  
  		public static Type[] RegTypes { get { return m_RegTypes; } }
  
  		private static readonly Type[] m_NecroRegTypes = new[] { typeof(BatWing), typeof(GraveDust), typeof(DaemonBlood), typeof(NoxCrystal), typeof(PigIron) };
  
  		public static Type[] NecroRegTypes { get { return m_NecroRegTypes; } }
  
  		private static readonly Type[] m_PotionTypes = new[]
  		{
  			typeof(AgilityPotion), typeof(StrengthPotion), typeof(RefreshPotion), typeof(LesserCurePotion),
  			typeof(LesserHealPotion), typeof(LesserPoisonPotion)
  		};
  
  		public static Type[] PotionTypes { get { return m_PotionTypes; } }
  
  		private static readonly Type[] m_SEInstrumentTypes = new[] { typeof(BambooFlute) };
  
  		public static Type[] SEInstrumentTypes { get { return m_SEInstrumentTypes; } }
  
  		private static readonly Type[] m_InstrumentTypes = new[] { typeof(Drums), typeof(Harp), typeof(LapHarp), typeof(Lute), typeof(Tambourine), typeof(TambourineTassel) };
  
  		public static Type[] InstrumentTypes { get { return m_InstrumentTypes; } }
  
  		private static readonly Type[] m_StatueTypes = new[]
  		{
  			typeof(StatueSouth), typeof(StatueSouth2), typeof(StatueNorth), typeof(StatueWest), typeof(StatueEast),
  			typeof(StatueEast2), typeof(StatueSouthEast), typeof(BustSouth), typeof(BustEast)
  		};
  
  		public static Type[] StatueTypes { get { return m_StatueTypes; } }
  
  		private static readonly Type[] m_RegularScrollTypes = new[]
  		{
  			typeof(ReactiveArmorScroll), typeof(ClumsyScroll), typeof(CreateFoodScroll), typeof(FeeblemindScroll),
  			typeof(HealScroll), typeof(MagicArrowScroll), typeof(NightSightScroll), typeof(WeakenScroll), typeof(AgilityScroll),
  			typeof(CunningScroll), typeof(CureScroll), typeof(HarmScroll), typeof(MagicTrapScroll), typeof(MagicUnTrapScroll),
  			typeof(ProtectionScroll), typeof(StrengthScroll), typeof(BlessScroll), typeof(FireballScroll),
  			typeof(MagicLockScroll), typeof(PoisonScroll), typeof(TelekinisisScroll), typeof(TeleportScroll),
  			typeof(UnlockScroll), typeof(WallOfStoneScroll), typeof(ArchCureScroll), typeof(ArchProtectionScroll),
  			typeof(CurseScroll), typeof(FireFieldScroll), typeof(GreaterHealScroll), typeof(LightningScroll),
  			typeof(ManaDrainScroll), typeof(RecallScroll), typeof(BladeSpiritsScroll), typeof(DispelFieldScroll),
  			typeof(IncognitoScroll), typeof(MagicReflectScroll), typeof(MindBlastScroll), typeof(ParalyzeScroll),
  			typeof(PoisonFieldScroll), typeof(SummonCreatureScroll), typeof(DispelScroll), typeof(EnergyBoltScroll),
  			typeof(ExplosionScroll), typeof(InvisibilityScroll), typeof(MarkScroll), typeof(MassCurseScroll),
  			typeof(ParalyzeFieldScroll), typeof(RevealScroll), typeof(ChainLightningScroll), typeof(EnergyFieldScroll),
  			typeof(FlamestrikeScroll), typeof(GateTravelScroll), typeof(ManaVampireScroll), typeof(MassDispelScroll),
  			typeof(MeteorSwarmScroll), typeof(PolymorphScroll), typeof(EarthquakeScroll), typeof(EnergyVortexScroll),
  			typeof(ResurrectionScroll), typeof(SummonAirElementalScroll), typeof(SummonDaemonScroll),
  			typeof(SummonEarthElementalScroll), typeof(SummonFireElementalScroll), typeof(SummonWaterElementalScroll)
  		};
  
  		private static readonly Type[] m_NecromancyScrollTypes = new[]
  		{
  			typeof(AnimateDeadScroll), typeof(BloodOathScroll), typeof(CorpseSkinScroll), typeof(CurseWeaponScroll),
  			typeof(EvilOmenScroll), typeof(HorrificBeastScroll), typeof(LichFormScroll), typeof(MindRotScroll),
  			typeof(PainSpikeScroll), typeof(PoisonStrikeScroll), typeof(StrangleScroll), typeof(SummonFamiliarScroll),
  			typeof(VampiricEmbraceScroll), typeof(VengefulSpiritScroll), typeof(WitherScroll), typeof(WraithFormScroll)
  		};
  
  		private static readonly Type[] m_SENecromancyScrollTypes = new[]
  		{
  			typeof(AnimateDeadScroll), typeof(BloodOathScroll), typeof(CorpseSkinScroll), typeof(CurseWeaponScroll),
  			typeof(EvilOmenScroll), typeof(HorrificBeastScroll), typeof(LichFormScroll), typeof(MindRotScroll),
  			typeof(PainSpikeScroll), typeof(PoisonStrikeScroll), typeof(StrangleScroll), typeof(SummonFamiliarScroll),
  			typeof(VampiricEmbraceScroll), typeof(VengefulSpiritScroll), typeof(WitherScroll), typeof(WraithFormScroll),
  			typeof(ExorcismScroll)
  		};
  
  		private static readonly Type[] m_PaladinScrollTypes = new Type[0];
  
  		#region Mondain's Legacy
  		private static readonly Type[] m_ArcanistScrollTypes = new[]
  		{
  			typeof(ArcaneCircleScroll), typeof(GiftOfRenewalScroll), typeof(ImmolatingWeaponScroll), typeof(AttuneWeaponScroll),
  			typeof(ThunderstormScroll), typeof(NatureFuryScroll), /*typeof( SummonFeyScroll ),			typeof( SummonFiendScroll ),*/
  			typeof(ReaperFormScroll), typeof(WildfireScroll), typeof(EssenceOfWindScroll), typeof(DryadAllureScroll),
  			typeof(EtherealVoyageScroll), typeof(WordOfDeathScroll), typeof(GiftOfLifeScroll), typeof(ArcaneEmpowermentScroll)
  		};
  		#endregion
  
  		#region SA
  		private static readonly Type[] m_MysticismScrollTypes = new[]
  		{
  			typeof(NetherBoltScroll), typeof(HealingStoneScroll), typeof(PurgeMagicScroll), typeof(EagleStrikeScroll),
  			typeof(AnimatedWeaponScroll), typeof(StoneFormScroll), typeof(SpellTriggerScroll), typeof(CleansingWindsScroll),
  			typeof(BombardScroll), typeof(SpellPlagueScroll), typeof(HailStormScroll), typeof(NetherCycloneScroll),
  			typeof(RisingColossusScroll), typeof(SleepScroll), typeof(MassSleepScroll), typeof(EnchantScroll)
  		};
  		#endregion
  
  		public static Type[] RegularScrollTypes { get { return m_RegularScrollTypes; } }
  		public static Type[] NecromancyScrollTypes { get { return m_NecromancyScrollTypes; } }
  		public static Type[] SENecromancyScrollTypes { get { return m_SENecromancyScrollTypes; } }
  		public static Type[] PaladinScrollTypes { get { return m_PaladinScrollTypes; } }
  		public static Type[] MysticismScrollTypes { get { return m_MysticismScrollTypes; } }
  
  		#region Mondain's Legacy
  		public static Type[] ArcanistScrollTypes { get { return m_ArcanistScrollTypes; } }
  		#endregion
  
  		private static readonly Type[] m_GrimmochJournalTypes = new[]
  		{
  			typeof(GrimmochJournal1), typeof(GrimmochJournal2), typeof(GrimmochJournal3), typeof(GrimmochJournal6),
  			typeof(GrimmochJournal7), typeof(GrimmochJournal11), typeof(GrimmochJournal14), typeof(GrimmochJournal17),
  			typeof(GrimmochJournal23)
  		};
  
  		public static Type[] GrimmochJournalTypes { get { return m_GrimmochJournalTypes; } }
  
  		private static readonly Type[] m_LysanderNotebookTypes = new[]
  		{
  			typeof(LysanderNotebook1), typeof(LysanderNotebook2), typeof(LysanderNotebook3), typeof(LysanderNotebook7),
  			typeof(LysanderNotebook8), typeof(LysanderNotebook11)
  		};
  
  		public static Type[] LysanderNotebookTypes { get { return m_LysanderNotebookTypes; } }
  
  		private static readonly Type[] m_TavarasJournalTypes = new[]
  		{
  			typeof(TavarasJournal1), typeof(TavarasJournal2), typeof(TavarasJournal3), typeof(TavarasJournal6),
  			typeof(TavarasJournal7), typeof(TavarasJournal8), typeof(TavarasJournal9), typeof(TavarasJournal11),
  			typeof(TavarasJournal14), typeof(TavarasJournal16), typeof(TavarasJournal16b), typeof(TavarasJournal17),
  			typeof(TavarasJournal19)
  		};
  
  		public static Type[] TavarasJournalTypes { get { return m_TavarasJournalTypes; } }
  
  		private static readonly Type[] m_NewWandTypes = new[]
  		{
  			typeof(FireballWand), typeof(LightningWand), typeof(MagicArrowWand), typeof(GreaterHealWand), typeof(HarmWand),
  			typeof(HealWand)
  		};
  
  		public static Type[] NewWandTypes { get { return m_NewWandTypes; } }
  
  		private static readonly Type[] m_WandTypes = new[] { typeof(ClumsyWand), typeof(FeebleWand), typeof(ManaDrainWand), typeof(WeaknessWand) };
  
  		public static Type[] WandTypes { get { return m_WandTypes; } }
  
  		private static readonly Type[] m_OldWandTypes = new[] { typeof(IDWand) };
  		public static Type[] OldWandTypes { get { return m_OldWandTypes; } }
  
  		private static readonly Type[] m_SEClothingTypes = new[]
  		{
  			typeof(ClothNinjaJacket), typeof(FemaleKimono), typeof(Hakama), typeof(HakamaShita), typeof(JinBaori),
  			typeof(Kamishimo), typeof(MaleKimono), typeof(NinjaTabi), typeof(Obi), typeof(SamuraiTabi), typeof(TattsukeHakama),
  			typeof(Waraji)
  		};
  
  		public static Type[] SEClothingTypes { get { return m_SEClothingTypes; } }
  
  		private static readonly Type[] m_AosClothingTypes = new[]
  		{
  			typeof(FurSarong), typeof(FurCape), typeof(FlowerGarland), typeof(GildedDress), typeof(FurBoots), typeof(FormalShirt)
  			,
  		};
  
  		public static Type[] AosClothingTypes { get { return m_AosClothingTypes; } }
  
  		private static readonly Type[] m_ClothingTypes = new[]
  		{
  			typeof(Cloak), typeof(Bonnet), typeof(Cap), typeof(FeatheredHat), typeof(FloppyHat), typeof(JesterHat),
  			typeof(Surcoat), typeof(SkullCap), typeof(StrawHat), typeof(TallStrawHat), typeof(TricorneHat), typeof(WideBrimHat),
  			typeof(WizardsHat), typeof(BodySash), typeof(Doublet), typeof(Boots), typeof(FullApron), typeof(JesterSuit),
  			typeof(Sandals), typeof(Tunic), typeof(Shoes), typeof(Shirt), typeof(Kilt), typeof(Skirt), typeof(FancyShirt),
  			typeof(FancyDress), typeof(ThighBoots), typeof(LongPants), typeof(PlainDress), typeof(Robe), typeof(ShortPants),
  			typeof(HalfApron)
  		};
  
  		public static Type[] ClothingTypes { get { return m_ClothingTypes; } }
  
  		private static readonly Type[] m_SEHatTypes = new[] { typeof(ClothNinjaHood), typeof(Kasa) };
  
  		public static Type[] SEHatTypes { get { return m_SEHatTypes; } }
  
  		private static readonly Type[] m_AosHatTypes = new[]
  		{
  			typeof(FlowerGarland), typeof(BearMask), typeof(DeerMask) //Are Bear& Deer mask inside the Pre-AoS loottables too?
  		};
  
  		public static Type[] AosHatTypes { get { return m_AosHatTypes; } }
  
  		private static readonly Type[] m_HatTypes = new[]
  		{
  			typeof(SkullCap), typeof(Bandana), typeof(FloppyHat), typeof(Cap), typeof(WideBrimHat), typeof(StrawHat),
  			typeof(TallStrawHat), typeof(WizardsHat), typeof(Bonnet), typeof(FeatheredHat), typeof(TricorneHat),
  			typeof(JesterHat)
  		};
  
  		public static Type[] HatTypes { get { return m_HatTypes; } }
  
  		private static readonly Type[] m_LibraryBookTypes = new[]
  		{
  			typeof(GrammarOfOrcish), typeof(CallToAnarchy), typeof(ArmsAndWeaponsPrimer), typeof(SongOfSamlethe),
  			typeof(TaleOfThreeTribes), typeof(GuideToGuilds), typeof(BirdsOfBritannia), typeof(BritannianFlora),
  			typeof(ChildrenTalesVol2), typeof(TalesOfVesperVol1), typeof(DeceitDungeonOfHorror), typeof(DimensionalTravel),
  			typeof(EthicalHedonism), typeof(MyStory), typeof(DiversityOfOurLand), typeof(QuestOfVirtues), typeof(RegardingLlamas)
  			, typeof(TalkingToWisps), typeof(TamingDragons), typeof(BoldStranger), typeof(BurningOfTrinsic), typeof(TheFight),
  			typeof(LifeOfATravellingMinstrel), typeof(MajorTradeAssociation), typeof(RankingsOfTrades),
  			typeof(WildGirlOfTheForest), typeof(TreatiseOnAlchemy), typeof(VirtueBook)
  		};
  
  		public static Type[] LibraryBookTypes { get { return m_LibraryBookTypes; } }
  		#endregion
  
  		#region Accessors
  		public static BaseWand RandomWand()
  		{
  			if (Core.ML)
  			{
  				return Construct(m_NewWandTypes) as BaseWand;
  			}
  			
  			if (Core.AOS)
  			{
  				return Construct(m_WandTypes, m_NewWandTypes) as BaseWand;
  			}
  			
  			return Construct(m_OldWandTypes, m_WandTypes, m_NewWandTypes) as BaseWand;
  		}
  		
  		public static BaseClothing RandomClothing(bool inTokuno = false, bool isMondain = false, bool isStygian = false)
  		{
  			#region Stygian Abyss
  			if (Core.SA && isStygian)
  			{
  				return Construct(m_SAClothingTypes, m_AosClothingTypes, m_ClothingTypes) as BaseClothing;
  			}
  			#endregion
  
  			#region Mondain's Legacy
  			if (Core.ML && isMondain)
  			{
  				return Construct(m_MLClothingTypes, m_AosClothingTypes, m_ClothingTypes) as BaseClothing;
  			}
  			#endregion
  
  			if (Core.SE && inTokuno)
  			{
  				return Construct(m_SEClothingTypes, m_AosClothingTypes, m_ClothingTypes) as BaseClothing;
  			}
  
  			if (Core.AOS)
  			{
  				return Construct(m_AosClothingTypes, m_ClothingTypes) as BaseClothing;
  			}
  
  			return Construct(m_ClothingTypes) as BaseClothing;
  		}
  
  		public static BaseWeapon RandomRangedWeapon(bool inTokuno = false, bool isMondain = false, bool isStygian = false)
  		{
  			#region Stygian Abyss
  			if (Core.SA && isStygian)
  				return Construct(m_SARangedWeaponTypes, m_AosRangedWeaponTypes, m_RangedWeaponTypes) as BaseWeapon;
  			#endregion
  
  			#region Mondain's Legacy
  			if (Core.ML && isMondain)
  			{
  				return Construct(m_MLRangedWeaponTypes, m_AosRangedWeaponTypes, m_RangedWeaponTypes) as BaseWeapon;
  			}
  			#endregion
  
  			if (Core.SE && inTokuno)
  			{
  				return Construct(m_SERangedWeaponTypes, m_AosRangedWeaponTypes, m_RangedWeaponTypes) as BaseWeapon;
  			}
  
  			if (Core.AOS)
  			{
  				return Construct(m_AosRangedWeaponTypes, m_RangedWeaponTypes) as BaseWeapon;
  			}
  
  			return Construct(m_RangedWeaponTypes) as BaseWeapon;
  		}
  
  		public static BaseWeapon RandomWeapon(bool inTokuno = false, bool isMondain = false, bool isStygian = false)
  		{
  			#region Stygian Abyss
  			if (Core.SA && isStygian)
  				return Construct(m_SAWeaponTypes, m_AosWeaponTypes, m_WeaponTypes) as BaseWeapon;
  			#endregion
  
  			#region Mondain's Legacy
  			if (Core.ML && isMondain)
  			{
  				return Construct(m_MLWeaponTypes, m_AosWeaponTypes, m_WeaponTypes) as BaseWeapon;
  			}
  			#endregion
  
  			if (Core.SE && inTokuno)
  			{
  				return Construct(m_SEWeaponTypes, m_AosWeaponTypes, m_WeaponTypes) as BaseWeapon;
  			}
  
  			if (Core.AOS)
  			{
  				return Construct(m_AosWeaponTypes, m_WeaponTypes) as BaseWeapon;
  			}
  
  			return Construct(m_WeaponTypes) as BaseWeapon;
  		}
  
  		public static Item RandomWeaponOrJewelry(bool inTokuno = false, bool isMondain = false, bool isStygian = false)
  		{
  			#region Stygian Abyss
  			if (Core.SA && isStygian)
  				return Construct(m_SAWeaponTypes, m_AosWeaponTypes, m_WeaponTypes, m_JewelryTypes);
  			#endregion
  
  			#region Mondain's Legacy
  			if (Core.ML && isMondain)
  			{
  				return Construct(m_MLWeaponTypes, m_AosWeaponTypes, m_WeaponTypes, m_JewelryTypes);
  			}
  			#endregion
  
  			if (Core.SE && inTokuno)
  			{
  				return Construct(m_SEWeaponTypes, m_AosWeaponTypes, m_WeaponTypes, m_JewelryTypes);
  			}
  
  			if (Core.AOS)
  			{
  				return Construct(m_AosWeaponTypes, m_WeaponTypes, m_JewelryTypes);
  			}
  
  			return Construct(m_WeaponTypes, m_JewelryTypes);
  		}
  
  		public static BaseJewel RandomJewelry()
  		{
  			return Construct(m_JewelryTypes) as BaseJewel;
  		}
  		
  		public static BaseArmor RandomArmor(bool inTokuno = false, bool isMondain = false, bool isStygian = false)
  		{
  			#region Stygian Abyss
  			if (Core.SA && isStygian)
  				return Construct(m_SAArmorTypes, m_ArmorTypes) as BaseArmor;
  			#endregion
  
  			#region Mondain's Legacy
  
gt: 			if (Core.ML && isMondain)