Overwrite

Complete Overwrite of the Folder with the free shard. ServUO 57.3 has been added.

Scripts/Items/Equipment/Weapons/AssassinSpike.cs

@@ -0,0 +1,141 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(Shortblade))]
+    [FlipableAttribute(0x2D21, 0x2D2D)]
+    public class AssassinSpike : BaseKnife
+    {
+        [Constructable]
+        public AssassinSpike()
+            : base(0x2D21)
+        {
+            this.Weight = 4.0;
+        }
+
+        public AssassinSpike(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfectiousStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ShadowStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x239;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 30;
+            }
+        }// TODO
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 60;
+            }
+        }// TODO
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Axe.cs

@@ -0,0 +1,127 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(GargishAxe))]
+    [FlipableAttribute(0xF49, 0xF4a)]
+    public class Axe : BaseAxe
+    {
+        [Constructable]
+        public Axe()
+            : base(0xF49)
+        {
+            this.Weight = 4.0;
+        }
+
+        public Axe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.CrushingBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Dismount;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Bardiche.cs

@@ -0,0 +1,127 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(GargishBardiche))]
+    [FlipableAttribute(0xF4D, 0xF4E)]
+    public class Bardiche : BasePoleArm
+    {
+        [Constructable]
+        public Bardiche()
+            : base(0xF4D)
+        {
+            this.Weight = 7.0;
+        }
+
+        public Bardiche(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ParalyzingBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Dismount;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 28;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 43;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 26;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 100;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BaseAxe.cs

@@ -0,0 +1,162 @@
+using System;
+using System.Collections.Generic;
+using Server.ContextMenus;
+using Server.Engines.Harvest;
+
+namespace Server.Items
+{
+    public interface IAxe
+    {
+        bool Axe(Mobile from, BaseAxe axe);
+    }
+
+    public abstract class BaseAxe : BaseMeleeWeapon, IHarvestTool
+    {
+        public BaseAxe(int itemID)
+            : base(itemID)
+        {
+        }
+
+        public BaseAxe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x232;
+            }
+        }
+
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Swords;
+            }
+        }
+
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Axe;
+            }
+        }
+
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Slash2H;
+            }
+        }
+
+        public virtual HarvestSystem HarvestSystem
+        {
+            get
+            {
+                return Lumberjacking.System;
+            }
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (HarvestSystem == null || Deleted)
+                return;
+
+            Point3D loc = GetWorldLocation();
+
+            if (!from.InLOS(loc) || !from.InRange(loc, 2))
+            {
+                from.LocalOverheadMessage(Server.Network.MessageType.Regular, 0x3E9, 1019045); // I can't reach that
+                return;
+            }
+            else if (!IsAccessibleTo(from))
+            {
+                PublicOverheadMessage(Server.Network.MessageType.Regular, 0x3E9, 1061637); // You are not allowed to access 
+                return;
+            }
+
+            if (!(HarvestSystem is Mining))
+                from.SendLocalizedMessage(1010018); // What do you want to use this item on?
+
+            HarvestSystem.BeginHarvesting(from, this);
+        }
+
+        public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
+        {
+            base.GetContextMenuEntries(from, list);
+
+            if (HarvestSystem == null)
+            	return;
+
+            BaseHarvestTool.AddContextMenuEntries(from, this, list, HarvestSystem);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)3); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 3:
+                    break;
+                case 2:
+                    {
+                        if(version == 2)
+                            ShowUsesRemaining = reader.ReadBool();
+                        goto case 1;
+                    }
+                case 1:
+                    {
+                        if(version == 2)
+                            UsesRemaining = reader.ReadInt();
+                        goto case 0;
+                    }
+                case 0:
+                    {
+                        break;
+                    }
+            }
+        }
+
+        public override void OnHit(Mobile attacker, IDamageable defender, double damageBonus)
+        {
+            base.OnHit(attacker, defender, damageBonus);
+
+            if (!Core.AOS && defender is Mobile && (attacker.Player || attacker.Body.IsHuman) && Layer == Layer.TwoHanded && (attacker.Skills[SkillName.Anatomy].Value / 400.0) >= Utility.RandomDouble())
+            {
+                StatMod mod = ((Mobile)defender).GetStatMod("Concussion");
+
+                if (mod == null)
+                {
+                    ((Mobile)defender).SendMessage("You receive a concussion blow!");
+                    ((Mobile)defender).AddStatMod(new StatMod(StatType.Int, "Concussion", -(((Mobile)defender).RawInt / 2), TimeSpan.FromSeconds(30.0)));
+
+                    attacker.SendMessage("You deliver a concussion blow!");
+                    attacker.PlaySound(0x308);
+                }
+            }
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BaseBashing.cs

@@ -0,0 +1,89 @@
+using System;
+
+namespace Server.Items
+{
+    public abstract class BaseBashing : BaseMeleeWeapon
+    {
+        public BaseBashing(int itemID)
+            : base(itemID)
+        {
+        }
+
+        public BaseBashing(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x233;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x239;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Macing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Bashing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Bash1H;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnHit(Mobile attacker, IDamageable defender, double damageBonus)
+        {
+            base.OnHit(attacker, defender, damageBonus);
+
+            if(defender is Mobile)
+                ((Mobile)defender).Stam -= Utility.Random(3, 3); // 3-5 points of stamina loss
+        }
+
+        public override double GetBaseDamage(Mobile attacker)
+        {
+            double damage = base.GetBaseDamage(attacker);
+
+            if (!Core.AOS && (attacker.Player || attacker.Body.IsHuman) && this.Layer == Layer.TwoHanded && (attacker.Skills[SkillName.Anatomy].Value / 400.0) >= Utility.RandomDouble())
+            {
+                damage *= 1.5;
+
+                attacker.SendMessage("You deliver a crushing blow!"); // Is this not localized?
+                attacker.PlaySound(0x11C);
+            }
+
+            return damage;
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BaseKnife.cs

@@ -0,0 +1,87 @@
+using System;
+using Server.Targets;
+
+namespace Server.Items
+{
+    public abstract class BaseKnife : BaseMeleeWeapon
+    {
+        public BaseKnife(int itemID)
+            : base(itemID)
+        {
+        }
+
+        public BaseKnife(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23B;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Swords;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Slashing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Slash1H;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            from.SendLocalizedMessage(1010018); // What do you want to use this item on?
+
+            from.Target = new BladedItemTarget(this);
+        }
+
+        public override void OnHit(Mobile attacker, IDamageable defender, double damageBonus)
+        {
+            base.OnHit(attacker, defender, damageBonus);
+
+            if (!Core.AOS && defender is Mobile && this.Poison != null && this.PoisonCharges > 0)
+            {
+                --this.PoisonCharges;
+
+                if (Utility.RandomDouble() >= 0.5) // 50% chance to poison
+                    ((Mobile)defender).ApplyPoison(attacker, this.Poison);
+            }
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BaseMeleeWeapon.cs

@@ -0,0 +1,65 @@
+using System;
+using Server.Spells.Spellweaving;
+
+namespace Server.Items
+{
+    public abstract class BaseMeleeWeapon : BaseWeapon
+    {
+        public BaseMeleeWeapon(int itemID)
+            : base(itemID)
+        {
+        }
+
+        public BaseMeleeWeapon(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int AbsorbDamage(Mobile attacker, Mobile defender, int damage)
+        {
+            damage = base.AbsorbDamage(attacker, defender, damage);
+
+            if (Core.AOS)
+                return damage;
+			
+            int absorb = defender.MeleeDamageAbsorb;
+
+            if (absorb > 0)
+            {
+                if (absorb > damage)
+                {
+                    int react = damage / 5;
+
+                    if (react <= 0)
+                        react = 1;
+
+                    defender.MeleeDamageAbsorb -= damage;
+                    damage = 0;
+
+                    attacker.Damage(react, defender);
+
+                    attacker.PlaySound(0x1F1);
+                    attacker.FixedEffect(0x374A, 10, 16);
+                }
+                else
+                {
+                    defender.MeleeDamageAbsorb = 0;
+                    defender.SendLocalizedMessage(1005556); // Your reactive armor spell has been nullified.
+                    DefensiveSpell.Nullify(defender);
+                }
+            }
+
+            return damage;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BasePoleArm.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using Server.ContextMenus;
+using Server.Engines.Harvest;
+
+namespace Server.Items
+{
+    public abstract class BasePoleArm : BaseMeleeWeapon, IHarvestTool
+    {
+        public BasePoleArm(int itemID)
+            : base(itemID)
+        {
+        }
+
+        public BasePoleArm(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x237;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Swords;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Polearm;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Slash2H;
+            }
+        }
+        
+        public virtual HarvestSystem HarvestSystem
+        {
+            get
+            {
+                return Lumberjacking.System;
+            }
+        }
+       
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (this.HarvestSystem == null)
+                return;
+
+            if (this.IsChildOf(from.Backpack) || this.Parent == from)
+                this.HarvestSystem.BeginHarvesting(from, this);
+            else
+                from.SendLocalizedMessage(1042001); // That must be in your pack for you to use it.
+        }
+
+        public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
+        {
+            base.GetContextMenuEntries(from, list);
+
+            if (this.HarvestSystem != null)
+                BaseHarvestTool.AddContextMenuEntries(from, this, list, this.HarvestSystem);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)3); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 3:
+                    break;
+                case 2:
+                    {
+                        if(version == 2)
+                            ShowUsesRemaining = reader.ReadBool();
+                        goto case 1;
+                    }
+                case 1:
+                    {
+                        if(version == 2)
+                            UsesRemaining = reader.ReadInt();
+                        goto case 0;
+                    }
+                case 0:
+                    {
+                        break;
+                    }
+            }
+        }
+
+        public override void OnHit(Mobile attacker, IDamageable defender, double damageBonus)
+        {
+            base.OnHit(attacker, defender, damageBonus);
+
+            if (!Core.AOS && defender is Mobile && (attacker.Player || attacker.Body.IsHuman) && this.Layer == Layer.TwoHanded && (attacker.Skills[SkillName.Anatomy].Value / 400.0) >= Utility.RandomDouble())
+            {
+                StatMod mod = ((Mobile)defender).GetStatMod("Concussion");
+
+                if (mod == null)
+                {
+                    ((Mobile)defender).SendMessage("You receive a concussion blow!");
+                    ((Mobile)defender).AddStatMod(new StatMod(StatType.Int, "Concussion", -(((Mobile)defender).RawInt / 2), TimeSpan.FromSeconds(30.0)));
+
+                    attacker.SendMessage("You deliver a concussion blow!");
+                    attacker.PlaySound(0x11C);
+                }
+            }
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BaseRanged.cs

@@ -0,0 +1,273 @@
+#region References
+using System;
+
+using Server.Mobiles;
+using Server.Network;
+using Server.Spells;
+#endregion
+
+namespace Server.Items
+{
+	public abstract class BaseRanged : BaseMeleeWeapon
+	{
+		public abstract int EffectID { get; }
+		public abstract Type AmmoType { get; }
+		public abstract Item Ammo { get; }
+
+		public override int DefHitSound { get { return 0x234; } }
+		public override int DefMissSound { get { return 0x238; } }
+
+		public override SkillName DefSkill { get { return SkillName.Archery; } }
+		public override WeaponType DefType { get { return WeaponType.Ranged; } }
+		public override WeaponAnimation DefAnimation { get { return WeaponAnimation.ShootXBow; } }
+
+		public override SkillName AccuracySkill { get { return SkillName.Archery; } }
+
+		private Timer m_RecoveryTimer; // so we don't start too many timers
+		private int m_Velocity;
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public bool Balanced
+		{
+            get { return Attributes.BalancedWeapon > 0; }
+			set
+			{
+                if (value)
+                    Attributes.BalancedWeapon = 1;
+                else
+                    Attributes.BalancedWeapon = 0;
+			}
+		}
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public int Velocity
+		{
+			get { return m_Velocity; }
+			set
+			{
+				m_Velocity = value;
+				InvalidateProperties();
+			}
+		}
+
+		public BaseRanged(int itemID)
+			: base(itemID)
+		{ }
+
+		public BaseRanged(Serial serial)
+			: base(serial)
+		{ }
+
+		public override TimeSpan OnSwing(Mobile attacker, IDamageable damageable)
+		{
+            long nextShoot;
+
+            if (attacker is PlayerMobile)
+                nextShoot = ((PlayerMobile)attacker).NextMovementTime + (Core.SE ? 250 : Core.AOS ? 500 : 1000);
+            else
+                nextShoot = attacker.LastMoveTime + attacker.ComputeMovementSpeed();
+
+			// Make sure we've been standing still for .25/.5/1 second depending on Era
+            if (nextShoot <= Core.TickCount ||
+				(Core.AOS && WeaponAbility.GetCurrentAbility(attacker) is MovingShot))
+			{
+				bool canSwing = true;
+
+				if (Core.AOS)
+				{
+					canSwing = (!attacker.Paralyzed && !attacker.Frozen);
+
+					if (canSwing)
+					{
+						Spell sp = attacker.Spell as Spell;
+
+						canSwing = (sp == null || !sp.IsCasting || !sp.BlocksMovement);
+					}
+				}
+
+				if (canSwing && attacker.HarmfulCheck(damageable))
+				{
+					attacker.DisruptiveAction();
+					attacker.Send(new Swing(0, attacker, damageable));
+
+					if (OnFired(attacker, damageable))
+					{
+                        if (CheckHit(attacker, damageable))
+						{
+                            OnHit(attacker, damageable);
+						}
+						else
+						{
+                            OnMiss(attacker, damageable);
+						}
+					}
+				}
+
+				attacker.RevealingAction();
+
+				return GetDelay(attacker);
+			}
+			
+			attacker.RevealingAction();
+
+			return TimeSpan.FromSeconds(0.25);
+		}
+
+		public override void OnHit(Mobile attacker, IDamageable damageable, double damageBonus)
+		{
+            if (AmmoType != null && attacker.Player && damageable is Mobile && !((Mobile)damageable).Player && (((Mobile)damageable).Body.IsAnimal || ((Mobile)damageable).Body.IsMonster) &&
+				0.4 >= Utility.RandomDouble())
+			{
+				var ammo = Ammo;
+
+				if (ammo != null)
+				{
+					((Mobile)damageable).AddToBackpack(ammo);
+				}
+			}
+
+			base.OnHit(attacker, damageable, damageBonus);
+		}
+
+        public override void OnMiss(Mobile attacker, IDamageable damageable)
+		{
+			if (attacker.Player && 0.4 >= Utility.RandomDouble())
+			{
+				if (Core.SE)
+				{
+					PlayerMobile p = attacker as PlayerMobile;
+
+					if (p != null && AmmoType != null)
+					{
+						Type ammo = AmmoType;
+
+						if (p.RecoverableAmmo.ContainsKey(ammo))
+						{
+							p.RecoverableAmmo[ammo]++;
+						}
+						else
+						{
+							p.RecoverableAmmo.Add(ammo, 1);
+						}
+
+						if (!p.Warmode)
+						{
+							if (m_RecoveryTimer == null)
+							{
+								m_RecoveryTimer = Timer.DelayCall(TimeSpan.FromSeconds(10), p.RecoverAmmo);
+							}
+
+							if (!m_RecoveryTimer.Running)
+							{
+								m_RecoveryTimer.Start();
+							}
+						}
+					}
+				}
+				else
+				{
+					Point3D loc = damageable.Location;
+
+					var ammo = Ammo;
+
+					if (ammo != null)
+					{
+						ammo.MoveToWorld(
+							new Point3D(loc.X + Utility.RandomMinMax(-1, 1), loc.Y + Utility.RandomMinMax(-1, 1), loc.Z),
+							damageable.Map);
+					}
+				}
+			}
+
+			base.OnMiss(attacker, damageable);
+		}
+
+        public virtual bool OnFired(Mobile attacker, IDamageable damageable)
+		{
+			WeaponAbility ability = WeaponAbility.GetCurrentAbility(attacker);
+			
+			// Respect special moves that use no ammo
+			if (ability != null && ability.ConsumeAmmo == false)
+			{
+				return true;
+			}
+
+			if (attacker.Player)
+			{
+				BaseQuiver quiver = attacker.FindItemOnLayer(Layer.Cloak) as BaseQuiver;
+				Container pack = attacker.Backpack;
+
+                int lowerAmmo = AosAttributes.GetValue(attacker, AosAttribute.LowerAmmoCost);
+
+                if (quiver == null || Utility.Random(100) >= lowerAmmo)
+				{
+					// consume ammo
+					if (quiver != null && quiver.ConsumeTotal(AmmoType, 1))
+					{
+						quiver.InvalidateWeight();
+					}
+					else if (pack == null || !pack.ConsumeTotal(AmmoType, 1))
+					{
+						return false;
+					}
+				}
+				else if (quiver.FindItemByType(AmmoType) == null && (pack == null || pack.FindItemByType(AmmoType) == null))
+				{
+					// lower ammo cost should not work when we have no ammo at all
+					return false;
+				}
+			}
+
+            attacker.MovingEffect(damageable, EffectID, 18, 1, false, false);
+
+			return true;
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.Write(4); // version
+
+			writer.Write(m_Velocity);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			int version = reader.ReadInt();
+
+			switch (version)
+			{
+                case 4:
+				case 3:
+					{
+                        if (version == 3 && reader.ReadBool())
+                            Attributes.BalancedWeapon = 1;
+
+						m_Velocity = reader.ReadInt();
+
+						goto case 2;
+					}
+				case 2:
+				case 1:
+					{
+						break;
+					}
+				case 0:
+					{
+						/*m_EffectID =*/
+						reader.ReadInt();
+						break;
+					}
+			}
+
+			if (version < 2)
+			{
+				WeaponAttributes.MageWeapon = 0;
+				WeaponAttributes.UseBestSkill = 0;
+			}
+		}
+	}
+}

Scripts/Items/Equipment/Weapons/BaseSpear.cs

@@ -0,0 +1,88 @@
+using System;
+
+namespace Server.Items
+{
+    public abstract class BaseSpear : BaseMeleeWeapon
+    {
+        public BaseSpear(int itemID)
+            : base(itemID)
+        {
+        }
+
+        public BaseSpear(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23C;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Piercing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Pierce2H;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnHit(Mobile attacker, IDamageable defender, double damageBonus)
+        {
+            base.OnHit(attacker, defender, damageBonus);
+
+            if (!Core.AOS && defender is Mobile && this.Layer == Layer.TwoHanded && (attacker.Skills[SkillName.Anatomy].Value / 400.0) >= Utility.RandomDouble())
+            {
+                ((Mobile)defender).SendMessage("You receive a paralyzing blow!"); // Is this not localized?
+                ((Mobile)defender).Freeze(TimeSpan.FromSeconds(2.0));
+
+                attacker.SendMessage("You deliver a paralyzing blow!"); // Is this not localized?
+                attacker.PlaySound(0x11C);
+            }
+
+            if (!Core.AOS && defender is Mobile && this.Poison != null && this.PoisonCharges > 0)
+            {
+                --this.PoisonCharges;
+
+                if (Utility.RandomDouble() >= 0.5) // 50% chance to poison
+                    ((Mobile)defender).ApplyPoison(attacker, this.Poison);
+            }
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BaseStaff.cs

@@ -0,0 +1,74 @@
+using System;
+
+namespace Server.Items
+{
+    public abstract class BaseStaff : BaseMeleeWeapon
+    {
+        public BaseStaff(int itemID)
+            : base(itemID)
+        {
+        }
+
+        public BaseStaff(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x233;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x239;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Macing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Staff;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Bash2H;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnHit(Mobile attacker, IDamageable defender, double damageBonus)
+        {
+            base.OnHit(attacker, defender, damageBonus);
+
+            if(defender is Mobile)
+                ((Mobile)defender).Stam -= Utility.Random(3, 3); // 3-5 points of stamina loss
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BaseSword.cs

@@ -0,0 +1,73 @@
+using System;
+using Server.Targets;
+
+namespace Server.Items
+{
+    public abstract class BaseSword : BaseMeleeWeapon
+    {
+        public BaseSword(int itemID)
+            : base(itemID)
+        {
+        }
+
+        public BaseSword(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Swords;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Slashing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Slash1H;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            from.SendLocalizedMessage(1010018); // What do you want to use this item on?
+
+            from.Target = new BladedItemTarget(this);
+        }
+
+        public override void OnHit(Mobile attacker, IDamageable damageable, double damageBonus)
+        {
+            base.OnHit(attacker, damageable, damageBonus);
+
+            if (!Core.AOS && this.Poison != null && this.PoisonCharges > 0 && damageable is Mobile)
+            {
+                --this.PoisonCharges;
+
+                if (Utility.RandomDouble() >= 0.5) // 50% chance to poison
+                    ((Mobile)damageable).ApplyPoison(attacker, this.Poison);
+            }
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BaseThrown.cs

@@ -0,0 +1,197 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public abstract class BaseThrown : BaseRanged
+    {
+        private Mobile m_Thrower;
+        private Mobile m_Target;
+        private Point3D m_KillSave;
+
+        public BaseThrown(int itemID)
+            : base(itemID)
+        {
+        }
+
+        public BaseThrown(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public abstract int MinThrowRange { get; }
+        public virtual int MaxThrowRange
+        {
+            get
+            {
+                return MinThrowRange + 3;
+            }
+        }
+        public override int DefMaxRange
+        {
+            get
+            {
+                int baseRange = MaxThrowRange;
+
+                var attacker = Parent as Mobile;
+
+                if (attacker != null)
+                {
+                    /*
+                     * Each weapon has a base and max range available to it, where the base
+                     * range is modified by the player<65>s strength to determine the actual range.
+                     *
+                     * Determining the maximum range of each weapon while in use:
+                     * - Range = BaseRange + ((PlayerStrength - MinWeaponStrReq) / ((150 - MinWeaponStrReq) / 3))
+                     * - The absolute maximum range is capped at 11 tiles.
+                     *
+                     * As per OSI tests: with 140 Strength you achieve max range for all throwing weapons.
+                     */
+
+                    return (baseRange - 3) + ((attacker.Str - AosStrengthReq) / ((140 - AosStrengthReq) / 3));
+                }
+                else
+                {
+                    return baseRange;
+                }
+            }
+        }
+
+        public override int EffectID
+        {
+            get
+            {
+                return ItemID;
+            }
+        }
+
+        public override Type AmmoType
+        {
+            get
+            {
+                return null;
+            }
+        }
+
+        public override Item Ammo
+        {
+            get
+            {
+                return null;
+            }
+        }
+
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x5D3;
+            }
+        }
+
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x5D4;
+            }
+        }
+
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Throwing;
+            }
+        }
+
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Throwing;
+            }
+        }
+
+        public override SkillName AccuracySkill
+        {
+            get
+            {
+                return SkillName.Throwing;
+            }
+        }
+
+        /*public override TimeSpan OnSwing(Mobile attacker, IDamageable damageable)
+        {
+            TimeSpan ts = base.OnSwing(attacker, damageable);
+
+            // time it takes to throw it around including mystic arc
+            if (ts < TimeSpan.FromMilliseconds(1000))
+                ts = TimeSpan.FromMilliseconds(1000);
+
+            return ts;
+        }*/
+
+        public override bool OnFired(Mobile attacker, IDamageable damageable)
+        {
+            m_Thrower = attacker;
+
+            if (!attacker.InRange(damageable, 1))
+            {
+                attacker.MovingEffect(damageable, EffectID, 18, 1, false, false, Hue, 0);
+            }
+
+            return true;
+        }
+
+        public override void OnHit(Mobile attacker, IDamageable damageable, double damageBonus)
+        {
+            m_KillSave = damageable.Location;
+
+            if (!(WeaponAbility.GetCurrentAbility(attacker) is MysticArc))
+                Timer.DelayCall(TimeSpan.FromMilliseconds(333.0), new TimerCallback(ThrowBack));
+
+            base.OnHit(attacker, damageable, damageBonus);
+        }
+
+        public override void OnMiss(Mobile attacker, IDamageable damageable)
+        {
+            m_Target = damageable as Mobile;
+
+            if (!(WeaponAbility.GetCurrentAbility(attacker) is MysticArc))
+                Timer.DelayCall(TimeSpan.FromMilliseconds(333.0), new TimerCallback(ThrowBack));
+
+            base.OnMiss(attacker, damageable);
+        }
+
+        public virtual void ThrowBack()
+        {
+            if (m_Target != null)
+                m_Target.MovingEffect(m_Thrower, EffectID, 18, 1, false, false, Hue, 0);
+            else if (m_Thrower != null)
+                Effects.SendMovingParticles(new Entity(Serial.Zero, m_KillSave, m_Thrower.Map), m_Thrower, ItemID, 18, 0, false, false, Hue, 0, 9502, 1, 0, (EffectLayer)255, 0x100);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            if (version == 0)
+                InheritsItem = true;
+        }
+
+        #region Old Item Serialization Vars
+        /* DO NOT USE! Only used in serialization of abyss reaver that originally derived from Item */
+        public bool InheritsItem { get; protected set; }
+        #endregion
+    }
+}

Scripts/Items/Equipment/Weapons/BaseWand.cs

@@ -0,0 +1,394 @@
+using System;
+using System.Collections;
+using Server.Network;
+using Server.Spells;
+using Server.Targeting;
+
+namespace Server.Items
+{
+    public enum WandEffect
+    {
+        Clumsiness,
+        Identification,
+        Healing,
+        Feeblemindedness,
+        Weakness,
+        MagicArrow,
+        Harming,
+        Fireball,
+        GreaterHealing,
+        Lightning,
+        ManaDraining,
+        None
+    }
+
+    public abstract class BaseWand : BaseBashing
+    {
+        private WandEffect m_WandEffect;
+        private int m_Charges;
+        public BaseWand(WandEffect effect, int minCharges, int maxCharges)
+            : base(Utility.RandomList(0xDF2, 0xDF3, 0xDF4, 0xDF5))
+        {
+            this.Weight = 1.0;
+            this.Effect = effect;
+            this.Charges = Utility.RandomMinMax(minCharges, maxCharges);
+
+            if (Core.AOS && m_WandEffect < WandEffect.None)
+            {
+                this.Attributes.SpellChanneling = 1;
+                this.Attributes.CastSpeed = -1;
+                this.WeaponAttributes.MageWeapon = Utility.RandomMinMax(1, 10);
+            }
+        }
+
+        public BaseWand(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Dismount;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Disarm;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 9;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 0;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public virtual TimeSpan GetUseDelay
+        {
+            get
+            {
+                return TimeSpan.FromSeconds(4.0);
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public WandEffect Effect
+        {
+            get
+            {
+                return this.m_WandEffect;
+            }
+            set
+            {
+                this.m_WandEffect = value;
+                this.InvalidateProperties();
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int Charges
+        {
+            get
+            {
+                return this.m_Charges;
+            }
+            set
+            {
+                this.m_Charges = value;
+                this.InvalidateProperties();
+            }
+        }
+        public void ConsumeCharge(Mobile from)
+        {
+            --this.Charges;
+
+            if (this.Charges == 0)
+                from.SendLocalizedMessage(1019073); // This item is out of charges.
+
+            this.ApplyDelayTo(from);
+        }
+
+        public virtual void ApplyDelayTo(Mobile from)
+        {
+            from.BeginAction(typeof(BaseWand));
+            Timer.DelayCall(this.GetUseDelay, new TimerStateCallback(ReleaseWandLock_Callback), from);
+        }
+
+        public virtual void ReleaseWandLock_Callback(object state)
+        {
+            ((Mobile)state).EndAction(typeof(BaseWand));
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (!from.CanBeginAction(typeof(BaseWand)))
+            {
+                from.SendLocalizedMessage(1070860); // You must wait a moment for the wand to recharge.
+                return;
+            }
+
+            if (this.Parent == from)
+            {
+                if (this.Charges > 0)
+                    this.OnWandUse(from);
+                else
+                    from.SendLocalizedMessage(1019073); // This item is out of charges.
+            }
+            else
+            {
+                from.SendLocalizedMessage(502641); // You must equip this item to use it.
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+
+            writer.Write((int)this.m_WandEffect);
+            writer.Write((int)this.m_Charges);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 0:
+                    {
+                        this.m_WandEffect = (WandEffect)reader.ReadInt();
+                        this.m_Charges = (int)reader.ReadInt();
+
+                        break;
+                    }
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            switch ( this.m_WandEffect )
+            {
+                case WandEffect.Clumsiness:
+                    list.Add(1017326, this.m_Charges.ToString());
+                    break; // clumsiness charges: ~1_val~
+                case WandEffect.Identification:
+                    list.Add(1017350, this.m_Charges.ToString());
+                    break; // identification charges: ~1_val~
+                case WandEffect.Healing:
+                    list.Add(1017329, this.m_Charges.ToString());
+                    break; // healing charges: ~1_val~
+                case WandEffect.Feeblemindedness:
+                    list.Add(1017327, this.m_Charges.ToString());
+                    break; // feeblemind charges: ~1_val~
+                case WandEffect.Weakness:
+                    list.Add(1017328, this.m_Charges.ToString());
+                    break; // weakness charges: ~1_val~
+                case WandEffect.MagicArrow:
+                    list.Add(1060492, this.m_Charges.ToString());
+                    break; // magic arrow charges: ~1_val~
+                case WandEffect.Harming:
+                    list.Add(1017334, this.m_Charges.ToString());
+                    break; // harm charges: ~1_val~
+                case WandEffect.Fireball:
+                    list.Add(1060487, this.m_Charges.ToString());
+                    break; // fireball charges: ~1_val~
+                case WandEffect.GreaterHealing:
+                    list.Add(1017330, this.m_Charges.ToString());
+                    break; // greater healing charges: ~1_val~
+                case WandEffect.Lightning:
+                    list.Add(1060491, this.m_Charges.ToString());
+                    break; // lightning charges: ~1_val~
+                case WandEffect.ManaDraining:
+                    list.Add(1017339, this.m_Charges.ToString());
+                    break; // mana drain charges: ~1_val~
+            }
+        }
+
+        public override void OnSingleClick(Mobile from)
+        {
+            ArrayList attrs = new ArrayList();
+
+            if (this.DisplayLootType)
+            {
+                if (this.LootType == LootType.Blessed)
+                    attrs.Add(new EquipInfoAttribute(1038021)); // blessed
+                else if (this.LootType == LootType.Cursed)
+                    attrs.Add(new EquipInfoAttribute(1049643)); // cursed
+            }
+
+            if (!this.Identified)
+            {
+                attrs.Add(new EquipInfoAttribute(1038000)); // Unidentified
+            }
+            else
+            {
+                int num = 0;
+
+                switch ( this.m_WandEffect )
+                {
+                    case WandEffect.Clumsiness:
+                        num = 3002011;
+                        break;
+                    case WandEffect.Identification:
+                        num = 1044063;
+                        break;
+                    case WandEffect.Healing:
+                        num = 3002014;
+                        break;
+                    case WandEffect.Feeblemindedness:
+                        num = 3002013;
+                        break;
+                    case WandEffect.Weakness:
+                        num = 3002018;
+                        break;
+                    case WandEffect.MagicArrow:
+                        num = 3002015;
+                        break;
+                    case WandEffect.Harming:
+                        num = 3002022;
+                        break;
+                    case WandEffect.Fireball:
+                        num = 3002028;
+                        break;
+                    case WandEffect.GreaterHealing:
+                        num = 3002039;
+                        break;
+                    case WandEffect.Lightning:
+                        num = 3002040;
+                        break;
+                    case WandEffect.ManaDraining:
+                        num = 3002041;
+                        break;
+                }
+
+                if (num > 0)
+                    attrs.Add(new EquipInfoAttribute(num, this.m_Charges));
+            }
+
+            int number;
+
+            if (this.Name == null)
+            {
+                number = 1017085;
+            }
+            else
+            {
+                this.LabelTo(from, this.Name);
+                number = 1041000;
+            }
+
+            if (attrs.Count == 0 && this.Crafter == null && this.Name != null)
+                return;
+
+            EquipmentInfo eqInfo = new EquipmentInfo(number, this.Crafter, false, (EquipInfoAttribute[])attrs.ToArray(typeof(EquipInfoAttribute)));
+
+            from.Send(new DisplayEquipmentInfo(this, eqInfo));
+        }
+
+        public void Cast(Spell spell)
+        {
+            bool m = this.Movable;
+
+            this.Movable = false;
+            spell.Cast();
+            this.Movable = m;
+        }
+
+        public virtual void OnWandUse(Mobile from)
+        {
+            from.Target = new WandTarget(this);
+        }
+
+        public virtual void DoWandTarget(Mobile from, object o)
+        {
+            if (this.Deleted || this.Charges <= 0 || this.Parent != from || o is StaticTarget || o is LandTarget)
+                return;
+
+            if (this.OnWandTarget(from, o))
+                this.ConsumeCharge(from);
+        }
+
+        public virtual bool OnWandTarget(Mobile from, object o)
+        {
+            return true;
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BattleAxe.cs

@@ -0,0 +1,128 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(GargishBattleAxe))]
+    [FlipableAttribute(0xF47, 0xF48)]
+    public class BattleAxe : BaseAxe
+    {
+        [Constructable]
+        public BattleAxe()
+            : base(0xF47)
+        {
+            this.Weight = 4.0;
+            this.Layer = Layer.TwoHanded;
+        }
+
+        public BattleAxe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.BleedAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 19;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 38;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BlackStaff.cs

@@ -0,0 +1,125 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0xDF1, 0xDF0)]
+    public class BlackStaff : BaseStaff
+    {
+        [Constructable]
+        public BlackStaff()
+            : base(0xDF0)
+        {
+            this.Weight = 6.0;
+        }
+
+        public BlackStaff(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.WhirlwindAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ParalyzingBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 39;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 8;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BladedStaff.cs

@@ -0,0 +1,134 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DualPointedSpear))]
+    [FlipableAttribute(0x26BD, 0x26C7)]
+    public class BladedStaff : BaseSpear
+    {
+        [Constructable]
+        public BladedStaff()
+            : base(0x26BD)
+        {
+            this.Weight = 4.0;
+        }
+
+        public BladedStaff(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ArmorIgnore;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Dismount;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 21;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Swords;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BloodBlade.cs

@@ -0,0 +1,163 @@
+using System;
+
+namespace Server.Items
+{
+    // Based off a Kryss
+    [FlipableAttribute(0x8FE, 0x4072)]
+    public class BloodBlade : BaseSword
+    {
+        [Constructable]
+        public BloodBlade()
+            : base(0x8FE)
+        {
+            //Weight = 2.0;
+        }
+
+        public BloodBlade(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.BleedAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ParalyzingBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 53;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 3;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 28;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 53;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23C;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 90;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Piercing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Pierce1H;
+            }
+        }
+
+        public override Race RequiredRace { get { return Race.Gargoyle; } }
+        public override bool CanBeWornByGargoyles { get { return true; } }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Bokuto.cs

@@ -0,0 +1,139 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x27A8, 0x27F3)]
+    public class Bokuto : BaseSword
+    {
+        [Constructable]
+        public Bokuto()
+            : base(0x27A8)
+        {
+            this.Weight = 7.0;
+        }
+
+        public Bokuto(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Feint;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.NerveStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 53;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 9;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 53;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x536;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BoneHarvester.cs

@@ -0,0 +1,141 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(GargishBoneHarvester))]
+    [FlipableAttribute(0x26BB, 0x26C5)]
+    public class BoneHarvester : BaseSword
+    {
+        [Constructable]
+        public BoneHarvester()
+            : base(0x26BB)
+        {
+            this.Weight = 3.0;
+        }
+
+        public BoneHarvester(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ParalyzingBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MortalStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 36;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 36;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23B;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/BoneMachete.cs

@@ -0,0 +1,33 @@
+using System;
+
+namespace Server.Items
+{
+    public class BoneMachete : ElvenMachete
+    {
+        public override int InitMinHits { get { return 1; } }
+        public override int InitMaxHits { get { return 3; } }
+		public override int LabelNumber { get { return 1020526; } }// bone machete
+
+        [Constructable]
+        public BoneMachete()
+        {
+        }
+
+        public BoneMachete(Serial serial)
+            : base(serial)
+        {
+        } 
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.WriteEncodedInt(1); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadEncodedInt();           
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Boomerang.cs

@@ -0,0 +1,134 @@
+using System;
+
+namespace Server.Items
+{
+    public class Boomerang : BaseThrown
+    {
+        [Constructable]
+        public Boomerang()
+            : base(0x8FF)
+        {
+            Weight = 4.0;
+            Layer = Layer.OneHanded;
+        }
+
+        public Boomerang(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int MinThrowRange { get { return 4; } }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MysticArc;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        /*
+        Boomerang 0x8FF: MysticArc, ConcussionBlow
+        Cyclone 2305/0x901: MovingShot, InfusedThrow
+        Soul Glaive 2314/0x090A: ArmorIgnore, MortalStrike
+        */
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 9;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 41;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 60;
+            }
+        }
+
+        public override Race RequiredRace { get { return Race.Gargoyle; } }
+        public override bool CanBeWornByGargoyles { get { return true; } }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Bow.cs

@@ -0,0 +1,159 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x13B2, 0x13B1)]
+    public class Bow : BaseRanged
+    {
+        [Constructable]
+        public Bow()
+            : base(0x13B2)
+        {
+            Weight = 6.0;
+            Layer = Layer.TwoHanded;
+        }
+
+        public Bow(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int EffectID
+        {
+            get
+            {
+                return 0xF42;
+            }
+        }
+        public override Type AmmoType
+        {
+            get
+            {
+                return typeof(Arrow);
+            }
+        }
+        public override Item Ammo
+        {
+            get
+            {
+                return new Arrow();
+            }
+        }
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ParalyzingBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MortalStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return Core.ML ? 17 : 16;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return Core.ML ? 21 : 18;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 4.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 9;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 41;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int DefMaxRange
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 60;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.ShootBow;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Broadsword.cs

@@ -0,0 +1,141 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DreadSword))]
+    [FlipableAttribute(0xF5E, 0xF5F)]
+    public class Broadsword : BaseSword
+    {
+        [Constructable]
+        public Broadsword()
+            : base(0xF5E)
+        {
+            this.Weight = 6.0;
+        }
+
+        public Broadsword(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.CrushingBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ArmorIgnore;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 29;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x237;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 100;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/ButcherKnife.cs

@@ -0,0 +1,127 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(GargishButcherKnife))]
+    [FlipableAttribute(0x13F6, 0x13F7)]
+    public class ButcherKnife : BaseKnife
+    {
+        [Constructable]
+        public ButcherKnife()
+            : base(0x13F6)
+        {
+            this.Weight = 1.0;
+        }
+
+        public ButcherKnife(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfectiousStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Disarm;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 49;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Cleaver.cs

@@ -0,0 +1,125 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefTinkering), typeof(GargishCleaver))]
+    [FlipableAttribute(0xEC3, 0xEC2)]
+    public class Cleaver : BaseKnife
+    {
+        [Constructable]
+        public Cleaver()
+            : base(0xEC3)
+        {
+            Weight = 2.0;
+        }
+
+        public Cleaver(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.BleedAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfectiousStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 46;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Club.cs

@@ -0,0 +1,125 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x13b4, 0x13b3)]
+    public class Club : BaseBashing
+    {
+        [Constructable]
+        public Club()
+            : base(0x13B4)
+        {
+            this.Weight = 9.0;
+        }
+
+        public Club(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.CrushingBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Dismount;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 44;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 8;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 24;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/ClumsyWand.cs

@@ -0,0 +1,38 @@
+using System;
+using Server.Spells.First;
+
+namespace Server.Items
+{
+    public class ClumsyWand : BaseWand
+    {
+        [Constructable]
+        public ClumsyWand()
+            : base(WandEffect.Clumsiness, 5, 30)
+        {
+        }
+
+        public ClumsyWand(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnWandUse(Mobile from)
+        {
+            this.Cast(new ClumsySpell(from, this));
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/CompositeBow.cs

@@ -0,0 +1,160 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x26C2, 0x26CC)]
+    public class CompositeBow : BaseRanged
+    {
+        [Constructable]
+        public CompositeBow()
+            : base(0x26C2)
+        {
+            this.Weight = 5.0;
+        }
+
+        public CompositeBow(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int EffectID
+        {
+            get
+            {
+                return 0xF42;
+            }
+        }
+        public override Type AmmoType
+        {
+            get
+            {
+                return typeof(Arrow);
+            }
+        }
+        public override Item Ammo
+        {
+            get
+            {
+                return new Arrow();
+            }
+        }
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ArmorIgnore;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MovingShot;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return Core.ML ? 16 : 15;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 4.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int DefMaxRange
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.ShootBow;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/CrescentBlade.cs

@@ -0,0 +1,141 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(GargishTalwar))]
+    [FlipableAttribute(0x26C1, 0x26CB)]
+    public class CrescentBlade : BaseSword
+    {
+        [Constructable]
+        public CrescentBlade()
+            : base(0x26C1)
+        {
+            this.Weight = 1.0;
+        }
+
+        public CrescentBlade(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DoubleStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MortalStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 55;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 47;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 55;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 47;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23B;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 51;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 80;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Crossbow.cs

@@ -0,0 +1,154 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0xF50, 0xF4F)]
+    public class Crossbow : BaseRanged
+    {
+        [Constructable]
+        public Crossbow()
+            : base(0xF50)
+        {
+            this.Weight = 7.0;
+            this.Layer = Layer.TwoHanded;
+        }
+
+        public Crossbow(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int EffectID
+        {
+            get
+            {
+                return 0x1BFE;
+            }
+        }
+        public override Type AmmoType
+        {
+            get
+            {
+                return typeof(Bolt);
+            }
+        }
+        public override Item Ammo
+        {
+            get
+            {
+                return new Bolt();
+            }
+        }
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MortalStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return Core.ML ? 22 : 22;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 24;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 4.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 8;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 43;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int DefMaxRange
+        {
+            get
+            {
+                return 8;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 80;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Cutlass.cs

@@ -0,0 +1,139 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x1441, 0x1440)]
+    public class Cutlass : BaseSword
+    {
+        [Constructable]
+        public Cutlass()
+            : base(0x1441)
+        {
+            this.Weight = 8.0;
+        }
+
+        public Cutlass(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.BleedAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ShadowStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 44;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 28;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23B;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Cyclone.cs

@@ -0,0 +1,129 @@
+using System;
+
+namespace Server.Items
+{
+    public class Cyclone : BaseThrown
+    {
+        [Constructable]
+        public Cyclone()
+            : base(0x901)
+        {
+            this.Weight = 6.0;
+            this.Layer = Layer.OneHanded;
+        }
+
+        public Cyclone(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int MinThrowRange { get { return 6; } }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MovingShot;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfusedThrow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 9;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 41;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 60;
+            }
+        }
+        
+        public override Race RequiredRace { get { return Race.Gargoyle; } }
+        public override bool CanBeWornByGargoyles { get { return true; } }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Dagger.cs

@@ -0,0 +1,148 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(GargishDagger))]
+    [FlipableAttribute(0xF52, 0xF51)]
+    public class Dagger : BaseKnife
+    {
+        [Constructable]
+        public Dagger()
+            : base(0xF52)
+        {
+            this.Weight = 1.0;
+        }
+
+        public Dagger(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ShadowStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfectiousStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 56;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 1;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 3;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 55;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Piercing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Pierce1H;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Daisho.cs

@@ -0,0 +1,142 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(GargishDaisho))]
+    [FlipableAttribute(0x27A9, 0x27F4)]
+    public class Daisho : BaseSword
+    {
+        [Constructable]
+        public Daisho()
+            : base(0x27A9)
+        {
+            this.Weight = 8.0;
+            this.Layer = Layer.TwoHanded;
+        }
+
+        public Daisho(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Feint;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DoubleStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23B;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 65;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/DiamondMace.cs

@@ -0,0 +1,127 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DiscMace))]
+    [FlipableAttribute(0x2D24, 0x2D30)]
+    public class DiamondMace : BaseBashing
+    {
+        [Constructable]
+        public DiamondMace()
+            : base(0x2D24)
+        {
+            this.Weight = 10.0;
+        }
+
+        public DiamondMace(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.CrushingBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 30;
+            }
+        }// TODO
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 60;
+            }
+        }// TODO
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/DiscMace.cs

@@ -0,0 +1,128 @@
+using System;
+
+namespace Server.Items
+{
+    // Based off a WarMace
+    [FlipableAttribute(0x903, 0x406E)]
+    public class DiscMace : BaseBashing
+    {
+        [Constructable]
+        public DiscMace()
+            : base(0x903)
+        {
+            //Weight = 17.0;
+        }
+
+        public DiscMace(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ArmorIgnore;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Disarm;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 26;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 32;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        
+        public override Race RequiredRace { get { return Race.Gargoyle; } }
+        public override bool CanBeWornByGargoyles { get { return true; } }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/DoubleAxe.cs

@@ -0,0 +1,127 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DualShortAxes))]
+    [FlipableAttribute(0xf4b, 0xf4c)]
+    public class DoubleAxe : BaseAxe
+    {
+        [Constructable]
+        public DoubleAxe()
+            : base(0xF4B)
+        {
+            this.Weight = 8.0;
+        }
+
+        public DoubleAxe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DoubleStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.WhirlwindAttack;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/DoubleBladedStaff.cs

@@ -0,0 +1,127 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DualPointedSpear))]
+    [FlipableAttribute(0x26BF, 0x26C9)]
+    public class DoubleBladedStaff : BaseSpear
+    {
+        [Constructable]
+        public DoubleBladedStaff()
+            : base(0x26BF)
+        {
+            this.Weight = 2.0;
+        }
+
+        public DoubleBladedStaff(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DoubleStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfectiousStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 49;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 49;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 80;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/DreadSword.cs

@@ -0,0 +1,142 @@
+using System;
+
+namespace Server.Items
+{
+    // Based off a Longsword
+    [FlipableAttribute(0x90B, 0x4074)]
+    public class DreadSword : BaseSword
+    {
+        [Constructable]
+        public DreadSword()
+            : base(0x90B)
+        {
+            //Weight = 7.0;
+        }
+
+        public DreadSword(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.CrushingBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x237;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+
+        public override Race RequiredRace { get { return Race.Gargoyle; } }
+        public override bool CanBeWornByGargoyles { get { return true; } }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/DualPointedSpear.cs

@@ -0,0 +1,128 @@
+using System;
+
+namespace Server.Items
+{
+    // Based off a Spear
+    [FlipableAttribute(0x904, 0x406D)]
+    public class DualPointedSpear : BaseSpear
+    {
+        [Constructable]
+        public DualPointedSpear()
+            : base(0x904)
+        {
+            //Weight = 7.0;
+        }
+
+        public DualPointedSpear(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DoubleStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Disarm;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 42;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 36;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 46;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 80;
+            }
+        }
+
+        public override Race RequiredRace { get { return Race.Gargoyle; } }
+        public override bool CanBeWornByGargoyles { get { return true; } }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/DualShortAxes.cs

@@ -0,0 +1,138 @@
+using System;
+
+namespace Server.Items
+{
+    // Based off a DoubleAxe
+    [FlipableAttribute(0x8FD, 0x4068)]
+    public class DualShortAxes : BaseAxe
+    {
+        [Constructable]
+        public DualShortAxes()
+            : base(0x8FD)
+        {
+            //Weight = 8.0;
+        }
+
+        public DualShortAxes(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DoubleStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfectiousStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/ElvenCompositeLongbow.cs

@@ -0,0 +1,160 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x2D1E, 0x2D2A)]
+    public class ElvenCompositeLongbow : BaseRanged
+    {
+        [Constructable]
+        public ElvenCompositeLongbow()
+            : base(0x2D1E)
+        {
+            this.Weight = 8.0;
+        }
+
+        public ElvenCompositeLongbow(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int EffectID
+        {
+            get
+            {
+                return 0xF42;
+            }
+        }
+        public override Type AmmoType
+        {
+            get
+            {
+                return typeof(Arrow);
+            }
+        }
+        public override Item Ammo
+        {
+            get
+            {
+                return new Arrow();
+            }
+        }
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ForceArrow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.SerpentArrow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 19;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 27;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 27;
+            }
+        }
+        public override int DefMaxRange
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 41;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 90;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.ShootBow;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/ElvenMachete.cs

@@ -0,0 +1,139 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x2D35, 0x2D29)]
+    public class ElvenMachete : BaseSword
+    {
+        [Constructable]
+        public ElvenMachete()
+            : base(0x2D35)
+        {
+            this.Weight = 6.0;
+        }
+
+        public ElvenMachete(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DefenseMastery;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Bladeweave;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 41;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 41;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23B;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x239;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 60;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/ElvenSpellblade.cs

@@ -0,0 +1,142 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DualPointedSpear))]
+    [FlipableAttribute(0x2D20, 0x2D2C)]
+    public class ElvenSpellblade : BaseKnife
+    {
+        [Constructable]
+        public ElvenSpellblade()
+            : base(0x2D20)
+        {
+            this.Weight = 5.0;
+            this.Layer = Layer.TwoHanded;
+        }
+
+        public ElvenSpellblade(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.PsychicAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.BleedAttack;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 44;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 44;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x239;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 60;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/EmeraldMace.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace Server.Items
+{
+    public class EmeraldMace : DiamondMace
+    {
+        [Constructable]
+        public EmeraldMace()
+        {
+            this.WeaponAttributes.ResistPoisonBonus = 5;
+        }
+
+        public EmeraldMace(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1073530;
+            }
+        }// emerald mace
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/ExecutionersAxe.cs

@@ -0,0 +1,127 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DualShortAxes))]
+    [FlipableAttribute(0xf45, 0xf46)]
+    public class ExecutionersAxe : BaseAxe
+    {
+        [Constructable]
+        public ExecutionersAxe()
+            : base(0xF45)
+        {
+            this.Weight = 8.0;
+        }
+
+        public ExecutionersAxe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.BleedAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MortalStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/FeebleWand.cs

@@ -0,0 +1,38 @@
+using System;
+using Server.Spells.First;
+
+namespace Server.Items
+{
+    public class FeebleWand : BaseWand
+    {
+        [Constructable]
+        public FeebleWand()
+            : base(WandEffect.Feeblemindedness, 5, 30)
+        {
+        }
+
+        public FeebleWand(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnWandUse(Mobile from)
+        {
+            this.Cast(new FeeblemindSpell(from, this));
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/FireballWand.cs

@@ -0,0 +1,38 @@
+using System;
+using Server.Spells.Third;
+
+namespace Server.Items
+{
+    public class FireballWand : BaseWand
+    {
+        [Constructable]
+        public FireballWand()
+            : base(WandEffect.Fireball, 5, Core.ML ? 109 : 15)
+        {
+        }
+
+        public FireballWand(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnWandUse(Mobile from)
+        {
+            this.Cast(new FireballSpell(from, this));
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/FireworksWand.cs

@@ -0,0 +1,148 @@
+using System;
+
+namespace Server.Items
+{
+    public class FireworksWand : MagicWand
+    {
+        private int m_Charges;
+        [Constructable]
+        public FireworksWand()
+            : this(100)
+        {
+        }
+
+        [Constructable]
+        public FireworksWand(int charges)
+        {
+            this.m_Charges = charges;
+            this.LootType = LootType.Blessed;
+        }
+
+        public FireworksWand(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1041424;
+            }
+        }// a fireworks wand
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int Charges
+        {
+            get
+            {
+                return this.m_Charges;
+            }
+            set
+            {
+                this.m_Charges = value;
+                this.InvalidateProperties();
+            }
+        }
+        public override void AddNameProperties(ObjectPropertyList list)
+        {
+            base.AddNameProperties(list);
+
+            list.Add(1060741, this.m_Charges.ToString()); // charges: ~1_val~
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            this.BeginLaunch(from, true);
+        }
+
+        public void BeginLaunch(Mobile from, bool useCharges)
+        {
+            Map map = from.Map;
+
+            if (map == null || map == Map.Internal)
+                return;
+
+            if (useCharges)
+            {
+                if (this.Charges > 0)
+                {
+                    --this.Charges;
+                }
+                else
+                {
+                    from.SendLocalizedMessage(502412); // There are no charges left on that item.
+                    return;
+                }
+            }
+
+            from.SendLocalizedMessage(502615); // You launch a firework!
+
+            Point3D ourLoc = this.GetWorldLocation();
+
+            Point3D startLoc = new Point3D(ourLoc.X, ourLoc.Y, ourLoc.Z + 10);
+            Point3D endLoc = new Point3D(startLoc.X + Utility.RandomMinMax(-2, 2), startLoc.Y + Utility.RandomMinMax(-2, 2), startLoc.Z + 32);
+
+            Effects.SendMovingEffect(new Entity(Serial.Zero, startLoc, map), new Entity(Serial.Zero, endLoc, map),
+                0x36E4, 5, 0, false, false);
+
+            Timer.DelayCall(TimeSpan.FromSeconds(1.0), new TimerStateCallback(FinishLaunch), new object[] { from, endLoc, map });
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+
+            writer.Write((int)this.m_Charges);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 0:
+                    {
+                        this.m_Charges = reader.ReadInt();
+                        break;
+                    }
+            }
+        }
+
+        private void FinishLaunch(object state)
+        {
+            object[] states = (object[])state;
+
+            Mobile from = (Mobile)states[0];
+            Point3D endLoc = (Point3D)states[1];
+            Map map = (Map)states[2];
+
+            int hue = Utility.Random(40);
+
+            if (hue < 8)
+                hue = 0x66D;
+            else if (hue < 10)
+                hue = 0x482;
+            else if (hue < 12)
+                hue = 0x47E;
+            else if (hue < 16)
+                hue = 0x480;
+            else if (hue < 20)
+                hue = 0x47F;
+            else
+                hue = 0;
+
+            if (Utility.RandomBool())
+                hue = Utility.RandomList(0x47E, 0x47F, 0x480, 0x482, 0x66D);
+
+            int renderMode = Utility.RandomList(0, 2, 3, 4, 5, 7);
+
+            Effects.PlaySound(endLoc, map, Utility.Random(0x11B, 4));
+            Effects.SendLocationEffect(endLoc, map, 0x373A + (0x10 * Utility.Random(4)), 16, 10, hue, renderMode);
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Fists.cs

@@ -0,0 +1,403 @@
+using System;
+
+namespace Server.Items
+{
+    public class Fists : BaseMeleeWeapon
+    {
+        public static void Initialize()
+        {
+            if (Mobile.DefaultWeapon == null)
+                Mobile.DefaultWeapon = new Fists();
+
+            EventSink.DisarmRequest += new DisarmRequestEventHandler(EventSink_DisarmRequest);
+            EventSink.StunRequest += new StunRequestEventHandler(EventSink_StunRequest);
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Disarm;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ParalyzingBlow;
+            }
+        }
+
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 0;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 1;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.50f;
+            }
+        }
+
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 0;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 1;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 8;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 30;
+            }
+        }
+
+        public override int DefHitSound
+        {
+            get
+            {
+                return -1;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return -1;
+            }
+        }
+
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Wrestling;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Fists;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Wrestle;
+            }
+        }
+
+        public Fists()
+            : base(0)
+        {
+            Visible = false;
+            Movable = false;
+            Quality = ItemQuality.Normal;
+        }
+
+        public Fists(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override double GetDefendSkillValue(Mobile attacker, Mobile defender)
+        {
+            double wresValue = defender.Skills[SkillName.Wrestling].Value;
+            double anatValue = defender.Skills[SkillName.Anatomy].Value;
+            double evalValue = defender.Skills[SkillName.EvalInt].Value;
+            double incrValue = (anatValue + evalValue + 20.0) * 0.5;
+
+            if (incrValue > 120.0)
+                incrValue = 120.0;
+
+            if (wresValue > incrValue)
+                return wresValue;
+            else
+                return incrValue;
+        }
+
+        private void CheckPreAOSMoves(Mobile attacker, Mobile defender)
+        {
+            if (attacker.StunReady)
+            {
+                if (attacker.CanBeginAction(typeof(Fists)))
+                {
+                    if (attacker.Skills[SkillName.Anatomy].Value >= 80.0 && attacker.Skills[SkillName.Wrestling].Value >= 80.0)
+                    {
+                        if (attacker.Stam >= 15)
+                        {
+                            attacker.Stam -= 15;
+
+                            if (CheckMove(attacker, SkillName.Anatomy))
+                            {
+                                StartMoveDelay(attacker);
+
+                                attacker.StunReady = false;
+
+                                attacker.SendLocalizedMessage(1004013); // You successfully stun your opponent!
+                                defender.SendLocalizedMessage(1004014); // You have been stunned!
+
+                                defender.Freeze(TimeSpan.FromSeconds(4.0));
+                            }
+                            else
+                            {
+                                attacker.SendLocalizedMessage(1004010); // You failed in your attempt to stun.
+                                defender.SendLocalizedMessage(1004011); // Your opponent tried to stun you and failed.
+                            }
+                        }
+                        else
+                        {
+                            attacker.SendLocalizedMessage(1004009); // You are too fatigued to attempt anything.
+                        }
+                    }
+                    else
+                    {
+                        attacker.SendLocalizedMessage(1004008); // You are not skilled enough to stun your opponent.
+                        attacker.StunReady = false;
+                    }
+                }
+            }
+            else if (attacker.DisarmReady)
+            {
+                if (attacker.CanBeginAction(typeof(Fists)))
+                {
+                    if (defender.Player || defender.Body.IsHuman)
+                    {
+                        if (attacker.Skills[SkillName.ArmsLore].Value >= 80.0 && attacker.Skills[SkillName.Wrestling].Value >= 80.0)
+                        {
+                            if (attacker.Stam >= 15)
+                            {
+                                Item toDisarm = defender.FindItemOnLayer(Layer.OneHanded);
+
+                                if (toDisarm == null || !toDisarm.Movable)
+                                    toDisarm = defender.FindItemOnLayer(Layer.TwoHanded);
+
+                                Container pack = defender.Backpack;
+
+                                if (pack == null || toDisarm == null || !toDisarm.Movable)
+                                {
+                                    attacker.SendLocalizedMessage(1004001); // You cannot disarm your opponent.
+                                }
+                                else if (CheckMove(attacker, SkillName.ArmsLore))
+                                {
+                                    StartMoveDelay(attacker);
+
+                                    attacker.Stam -= 15;
+                                    attacker.DisarmReady = false;
+
+                                    attacker.SendLocalizedMessage(1004006); // You successfully disarm your opponent!
+                                    defender.SendLocalizedMessage(1004007); // You have been disarmed!
+
+                                    pack.DropItem(toDisarm);
+                                }
+                                else
+                                {
+                                    attacker.Stam -= 15;
+
+                                    attacker.SendLocalizedMessage(1004004); // You failed in your attempt to disarm.
+                                    defender.SendLocalizedMessage(1004005); // Your opponent tried to disarm you but failed.
+                                }
+                            }
+                            else
+                            {
+                                attacker.SendLocalizedMessage(1004003); // You are too fatigued to attempt anything.
+                            }
+                        }
+                        else
+                        {
+                            attacker.SendLocalizedMessage(1004002); // You are not skilled enough to disarm your opponent.
+                            attacker.DisarmReady = false;
+                        }
+                    }
+                    else
+                    {
+                        attacker.SendLocalizedMessage(1004001); // You cannot disarm your opponent.
+                    }
+                }
+            }
+        }
+
+        public override TimeSpan OnSwing(Mobile attacker, IDamageable defender)
+        {
+            if (!Core.AOS && defender is Mobile)
+                this.CheckPreAOSMoves(attacker, (Mobile)defender);
+
+            return base.OnSwing(attacker, defender);
+        }
+
+        /*public override void OnMiss( Mobile attacker, Mobile defender )
+        {
+        base.PlaySwingAnimation( attacker );
+        }*/
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            if (Mobile.DefaultWeapon == null)
+                Mobile.DefaultWeapon = this;
+            else
+                Delete();
+        }
+
+        /* Wrestling moves */
+
+        private static bool CheckMove(Mobile m, SkillName other)
+        {
+            double wresValue = m.Skills[SkillName.Wrestling].Value;
+            double scndValue = m.Skills[other].Value;
+
+            /* 40% chance at 80, 80
+            * 50% chance at 100, 100
+            * 60% chance at 120, 120
+            */
+
+            double chance = (wresValue + scndValue) / 400.0;
+
+            return (chance >= Utility.RandomDouble());
+        }
+
+        private static bool HasFreeHands(Mobile m)
+        {
+            Item item = m.FindItemOnLayer(Layer.OneHanded);
+
+            if (item != null && !(item is Spellbook))
+                return false;
+
+            return m.FindItemOnLayer(Layer.TwoHanded) == null;
+        }
+
+        private static void EventSink_DisarmRequest(DisarmRequestEventArgs e)
+        {
+            if (Core.AOS)
+                return;
+
+            Mobile m = e.Mobile;
+
+            double armsValue = m.Skills[SkillName.ArmsLore].Value;
+            double wresValue = m.Skills[SkillName.Wrestling].Value;
+
+            if (!HasFreeHands(m))
+            {
+                m.SendLocalizedMessage(1004029); // You must have your hands free to attempt to disarm your opponent.
+                m.DisarmReady = false;
+            }
+            else if (armsValue >= 80.0 && wresValue >= 80.0)
+            {
+                m.DisruptiveAction();
+                m.DisarmReady = !m.DisarmReady;
+                m.SendLocalizedMessage(m.DisarmReady ? 1019013 : 1019014);
+            }
+            else
+            {
+                m.SendLocalizedMessage(1004002); // You are not skilled enough to disarm your opponent.
+                m.DisarmReady = false;
+            }
+        }
+
+        private static void EventSink_StunRequest(StunRequestEventArgs e)
+        {
+            if (Core.AOS)
+                return;
+
+            Mobile m = e.Mobile;
+
+            double anatValue = m.Skills[SkillName.Anatomy].Value;
+            double wresValue = m.Skills[SkillName.Wrestling].Value;
+
+            if (!HasFreeHands(m))
+            {
+                m.SendLocalizedMessage(1004031); // You must have your hands free to attempt to stun your opponent.
+                m.StunReady = false;
+            }
+            else if (anatValue >= 80.0 && wresValue >= 80.0)
+            {
+                m.DisruptiveAction();
+                m.StunReady = !m.StunReady;
+                m.SendLocalizedMessage(m.StunReady ? 1019011 : 1019012);
+            }
+            else
+            {
+                m.SendLocalizedMessage(1004008); // You are not skilled enough to stun your opponent.
+                m.StunReady = false;
+            }
+        }
+
+        private class MoveDelayTimer : Timer
+        {
+            private readonly Mobile m_Mobile;
+
+            public MoveDelayTimer(Mobile m)
+                : base(TimeSpan.FromSeconds(10.0))
+            {
+                this.m_Mobile = m;
+
+                this.Priority = TimerPriority.TwoFiftyMS;
+
+                this.m_Mobile.BeginAction(typeof(Fists));
+            }
+
+            protected override void OnTick()
+            {
+                this.m_Mobile.EndAction(typeof(Fists));
+            }
+        }
+
+        private static void StartMoveDelay(Mobile m)
+        {
+            new MoveDelayTimer(m).Start();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Fukiya.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Collections.Generic;
+using Server.ContextMenus;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x27AA, 0x27F5)]
+    public class Fukiya : Item, INinjaWeapon
+    {
+        private int m_UsesRemaining;
+        private Poison m_Poison;
+        private int m_PoisonCharges;
+        [Constructable]
+        public Fukiya()
+            : base(0x27AA)
+        {
+            this.Weight = 4.0;
+            this.Layer = Layer.OneHanded;
+        }
+
+        public Fukiya(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public virtual int WrongAmmoMessage
+        {
+            get
+            {
+                return 1063329;
+            }
+        }//You can only load fukiya darts
+        public virtual int NoFreeHandMessage
+        {
+            get
+            {
+                return 1063327;
+            }
+        }//You must have a free hand to use a fukiya.
+        public virtual int EmptyWeaponMessage
+        {
+            get
+            {
+                return 1063325;
+            }
+        }//You have no fukiya darts!
+        public virtual int RecentlyUsedMessage
+        {
+            get
+            {
+                return 1063326;
+            }
+        }//You are already using that fukiya.
+        public virtual int FullWeaponMessage
+        {
+            get
+            {
+                return 1063330;
+            }
+        }//You can only load fukiya darts
+        public virtual int WeaponMinRange
+        {
+            get
+            {
+                return 0;
+            }
+        }
+        public virtual int WeaponMaxRange
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public virtual int WeaponDamage
+        {
+            get
+            {
+                return Utility.RandomMinMax(4, 6);
+            }
+        }
+        public Type AmmoType
+        {
+            get
+            {
+                return typeof(FukiyaDarts);
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int UsesRemaining
+        {
+            get
+            {
+                return this.m_UsesRemaining;
+            }
+            set
+            {
+                this.m_UsesRemaining = value;
+                this.InvalidateProperties();
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Poison Poison
+        {
+            get
+            {
+                return this.m_Poison;
+            }
+            set
+            {
+                this.m_Poison = value;
+                this.InvalidateProperties();
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int PoisonCharges
+        {
+            get
+            {
+                return this.m_PoisonCharges;
+            }
+            set
+            {
+                this.m_PoisonCharges = value;
+                this.InvalidateProperties();
+            }
+        }
+        public bool ShowUsesRemaining
+        {
+            get
+            {
+                return true;
+            }
+            set
+            {
+            }
+        }
+        public void AttackAnimation(Mobile from, Mobile to)
+        {
+            if (from.Body.IsHuman && !from.Mounted && !Core.SA)
+            {
+                from.Animate(33, 2, 1, true, true, 0);
+            }
+
+            from.PlaySound(0x223);
+            from.MovingEffect(to, 0x2804, 5, 0, false, false);
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            list.Add(1060584, this.m_UsesRemaining.ToString()); // uses remaining: ~1_val~
+
+            if (this.m_Poison != null && this.m_PoisonCharges > 0)
+                list.Add(1062412 + this.m_Poison.Level, this.m_PoisonCharges.ToString());
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            NinjaWeapon.AttemptShoot((PlayerMobile)from, this);
+        }
+
+        public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
+        {
+            base.GetContextMenuEntries(from, list);
+
+            if (this.IsChildOf(from))
+            {
+                list.Add(new NinjaWeapon.LoadEntry(this, 6224));
+                list.Add(new NinjaWeapon.UnloadEntry(this, 6225));
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0);
+
+            writer.Write((int)this.m_UsesRemaining);
+
+            Poison.Serialize(this.m_Poison, writer);
+            writer.Write((int)this.m_PoisonCharges);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 0:
+                    {
+                        this.m_UsesRemaining = reader.ReadInt();
+
+                        this.m_Poison = Poison.Deserialize(reader);
+                        this.m_PoisonCharges = reader.ReadInt();
+
+                        break;
+                    }
+            }
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishAxe.cs

@@ -0,0 +1,140 @@
+using System;
+
+namespace Server.Items
+{
+    //Based off Axe
+    [FlipableAttribute(0x48B2, 0x48B3)]
+    public class GargishAxe : BaseAxe
+    {
+        [Constructable]
+        public GargishAxe()
+            : base(0x48B2)
+        {
+            this.Weight = 4.0;
+        }
+
+        public GargishAxe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.CrushingBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Dismount;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishBardiche.cs

@@ -0,0 +1,140 @@
+using System;
+
+namespace Server.Items
+{
+    //Based Off Bardiche
+    [FlipableAttribute(0x48B4, 0x48B5)]
+    public class GargishBardiche : BasePoleArm
+    {
+        [Constructable]
+        public GargishBardiche()
+            : base(0x48B4)
+        {
+            this.Weight = 7.0;
+        }
+
+        public GargishBardiche(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ParalyzingBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Dismount;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 28;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 43;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 26;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 100;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishBattleAxe.cs

@@ -0,0 +1,141 @@
+using System;
+
+namespace Server.Items
+{
+    //Based Off Battle Axe
+    [FlipableAttribute(0x48B0, 0x48B1)]
+    public class GargishBattleAxe : BaseAxe
+    {
+        [Constructable]
+        public GargishBattleAxe()
+            : base(0x48B0)
+        {
+            this.Weight = 4.0;
+            this.Layer = Layer.TwoHanded;
+        }
+
+        public GargishBattleAxe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.BleedAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 19;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 38;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishBoneHarvester.cs

@@ -0,0 +1,154 @@
+using System;
+
+namespace Server.Items
+{
+    //Based off Bone Harvester
+    [FlipableAttribute(0x48C6, 0x48C7)]
+    public class GargishBoneHarvester : BaseSword
+    {
+        [Constructable]
+        public GargishBoneHarvester()
+            : base(0x48C6)
+        {
+            this.Weight = 3.0;
+        }
+
+        public GargishBoneHarvester(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ParalyzingBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MortalStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 36;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 36;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23B;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishButcherKnife.cs

@@ -0,0 +1,138 @@
+using System;
+
+namespace Server.Items
+{
+    //Based Off Butcher Knife
+    [FlipableAttribute(0x48B6, 0x48B7)]
+    public class GargishButcherKnife : BaseKnife
+    {
+        [Constructable]
+        public GargishButcherKnife()
+            : base(0x48B6)
+        {
+            Weight = 1.0;
+        }
+
+        public GargishButcherKnife(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfectiousStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Disarm;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 49;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishCleaver.cs

@@ -0,0 +1,138 @@
+using System;
+
+namespace Server.Items
+{
+    //Based off Cleaver
+    [FlipableAttribute(0x48AE, 0x48AF)]
+    public class GargishCleaver : BaseKnife
+    {
+        [Constructable]
+        public GargishCleaver()
+            : base(0x48AE)
+        {
+            Weight = 2.0;
+        }
+
+        public GargishCleaver(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.BleedAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfectiousStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 46;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishDagger.cs

@@ -0,0 +1,149 @@
+using System;
+
+namespace Server.Items
+{
+    // Based off a Dagger
+    [FlipableAttribute(0x902, 0x406A)]
+    public class GargishDagger : BaseKnife
+    {
+        [Constructable]
+        public GargishDagger()
+            : base(0x902)
+        {
+            //Weight = 1.0;
+        }
+
+        public GargishDagger(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ShadowStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfectiousStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 56;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 1;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 3;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 55;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Piercing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Pierce1H;
+            }
+        }
+
+        public override Race RequiredRace { get { return Race.Gargoyle; } }
+        public override bool CanBeWornByGargoyles { get { return true; } }
+        
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishDaisho.cs

@@ -0,0 +1,155 @@
+using System;
+
+namespace Server.Items
+{
+    //Bassed Off Daisho
+    [FlipableAttribute(0x48D0, 0x48D1)]
+    public class GargishDaisho : BaseSword
+    {
+        [Constructable]
+        public GargishDaisho()
+            : base(0x48D0)
+        {
+            this.Weight = 8.0;
+            this.Layer = Layer.TwoHanded;
+        }
+
+        public GargishDaisho(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Feint;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DoubleStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23B;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 65;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishGnarledStaff.cs

@@ -0,0 +1,140 @@
+using System;
+
+namespace Server.Items
+{
+    //Based Off Gnarled Staff
+    [FlipableAttribute(0x48B8, 0x48B9)]
+    public class GargishGnarledStaff : BaseStaff
+    {
+        [Constructable]
+        public GargishGnarledStaff()
+            : base(0x48B8)
+        {
+            this.Weight = 3.0;
+        }
+
+        public GargishGnarledStaff(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ForceOfNature;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishKatana.cs

@@ -0,0 +1,154 @@
+using System;
+
+namespace Server.Items
+{
+    //Based Off Katana
+    [FlipableAttribute(0x48BA, 0x48BB)]
+    public class GargishKatana : BaseSword
+    {
+        [Constructable]
+        public GargishKatana()
+            : base(0x48BA)
+        {
+            this.Weight = 6.0;
+        }
+
+        public GargishKatana(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DoubleStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ArmorIgnore;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 46;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 26;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 58;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23B;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 90;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishKryss.cs

@@ -0,0 +1,172 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x48BC, 0x48BD)]
+    public class GargishKryss : BaseSword
+    {
+        [Constructable]
+        public GargishKryss()
+            : base(0x48BC)
+        {
+            Weight = 2.0;
+        }
+
+        public GargishKryss(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ArmorIgnore;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfectiousStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 53;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 3;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 28;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 53;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23C;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 90;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Piercing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Pierce1H;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishLance.cs

@@ -0,0 +1,175 @@
+using System;
+
+namespace Server.Items
+{
+    //Based off Lance
+    [FlipableAttribute(0x48CA, 0x48CB)]
+    public class GargishLance : BaseSword
+    {
+        [Constructable]
+        public GargishLance()
+            : base(0x48CA)
+        {
+            this.Weight = 12.0;
+        }
+
+        public GargishLance(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Dismount;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 95;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 22;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 24;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 4.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 95;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 24;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23C;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Piercing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Pierce1H;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishMaul.cs

@@ -0,0 +1,137 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x48C2, 0x48C3)]
+    public class GargishMaul : BaseBashing
+    {
+        [Constructable]
+        public GargishMaul()
+            : base(0x48C2)
+        {
+            Weight = 10.0;
+        }
+
+        public GargishMaul(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DoubleStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 32;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishPike.cs

@@ -0,0 +1,140 @@
+using System;
+
+namespace Server.Items
+{
+    //Based Off Pike
+    [FlipableAttribute(0x48C8, 0x48C9)]
+    public class GargishPike : BaseSpear
+    {
+        [Constructable]
+        public GargishPike()
+            : base(0x48C8)
+        {
+            this.Weight = 8.0;
+        }
+
+        public GargishPike(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ParalyzingBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfectiousStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 37;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishScythe.cs

@@ -0,0 +1,146 @@
+using System;
+using Server.Engines.Harvest;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x48C4, 0x48C5)]
+    public class GargishScythe : BasePoleArm
+    {
+        [Constructable]
+        public GargishScythe()
+            : base(0x48C4)
+        {
+            Weight = 5.0;
+        }
+
+        public GargishScythe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.BleedAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ParalyzingBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 19;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 32;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 32;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 100;
+            }
+        }
+        public override HarvestSystem HarvestSystem
+        {
+            get
+            {
+                return null;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishTalwar.cs

@@ -0,0 +1,142 @@
+using System;
+
+namespace Server.Items
+{
+    // Based off a Halberd
+    [FlipableAttribute(0x908, 0x4075)]
+    public class GargishTalwar : BaseSword
+    {
+        [Constructable]
+        public GargishTalwar()
+            : base(0x908)
+        {
+            //Weight = 16.0;
+        }
+
+        public GargishTalwar(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.WhirlwindAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Dismount;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 19;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 49;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x237;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 80;
+            }
+        }
+
+        public override Race RequiredRace { get { return Race.Gargoyle; } }
+        public override bool CanBeWornByGargoyles { get { return true; } }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishTekagi.cs

@@ -0,0 +1,176 @@
+using System;
+
+namespace Server.Items
+{
+    //Bassed Off Tekagi
+    [FlipableAttribute(0x48CE, 0x48Cf)]
+    public class GargishTekagi : BaseKnife
+    {
+        [Constructable]
+        public GargishTekagi()
+            : base(0x48CE)
+        {
+            this.Weight = 5.0;
+            this.Layer = Layer.TwoHanded;
+        }
+
+        public GargishTekagi(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DualWield;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.TalonStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 53;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 53;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x232;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 60;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Piercing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Pierce1H;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishTessen.cs

@@ -0,0 +1,162 @@
+using System;
+
+namespace Server.Items
+{
+    //Based Of Tessen
+    [FlipableAttribute(0x48CC, 0x48CD)]
+    public class GargishTessen : BaseBashing
+    {
+        [Constructable]
+        public GargishTessen()
+            : base(0x48CC)
+        {
+            this.Weight = 6.0;
+            this.Layer = Layer.TwoHanded;
+        }
+
+        public GargishTessen(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Feint;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DualWield;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x232;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 55;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 60;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Bash2H;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishWarFork.cs

@@ -0,0 +1,161 @@
+using System;
+
+namespace Server.Items
+{
+    //Based Off War Fork
+    [FlipableAttribute(0x48BE, 0x48BF)]
+    public class GargishWarFork : BaseSpear
+    {
+        [Constructable]
+        public GargishWarFork()
+            : base(0x48BE)
+        {
+            this.Weight = 9.0;
+        }
+
+        public GargishWarFork(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.BleedAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Disarm;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 43;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 4;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 32;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x236;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Pierce1H;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GargishWarHammer.cs

@@ -0,0 +1,148 @@
+using System;
+
+namespace Server.Items
+{
+    //Based Off War Hammer
+    [FlipableAttribute(0x48C0, 0x481)]
+    public class GargishWarHammer : BaseBashing
+    {
+        [Constructable]
+        public GargishWarHammer()
+            : base(0x48C0)
+        {
+            this.Weight = 10.0;
+            this.Layer = Layer.TwoHanded;
+        }
+
+        public GargishWarHammer(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.WhirlwindAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.CrushingBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 95;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 28;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 8;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 36;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Bash2H;
+            }
+        }
+        public override Race RequiredRace
+        {
+            get
+            {
+                return Race.Gargoyle;
+            }
+        }
+        public override bool CanBeWornByGargoyles
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GlassStaff.cs

@@ -0,0 +1,128 @@
+using System;
+
+namespace Server.Items
+{
+    // Based off a BlackStaff
+    [FlipableAttribute(0x905, 0x4070)]
+    public class GlassStaff : BaseStaff
+    {
+        [Constructable]
+        public GlassStaff()
+            : base(0x905)
+        {
+            this.Weight = 4.0;
+        }
+
+        public GlassStaff(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DoubleStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MortalStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 39;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 8;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+
+        public override Race RequiredRace { get { return Race.Gargoyle; } }
+        public override bool CanBeWornByGargoyles { get { return true; } }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GlassSword.cs

@@ -0,0 +1,142 @@
+using System;
+
+namespace Server.Items
+{
+    // Based off a Katana
+    [FlipableAttribute(0x90C, 0x4073)]
+    public class GlassSword : BaseSword
+    {
+        [Constructable]
+        public GlassSword()
+            : base(0x90C)
+        {
+            this.Weight = 6.0;
+        }
+
+        public GlassSword(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.BleedAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MortalStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 46;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 26;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 58;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23B;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 90;
+            }
+        }
+
+        public override Race RequiredRace { get { return Race.Gargoyle; } }
+        public override bool CanBeWornByGargoyles { get { return true; } }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GnarledStaff.cs

@@ -0,0 +1,127 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefCarpentry), typeof(GargishGnarledStaff))]
+    [FlipableAttribute(0x13F8, 0x13F9)]
+    public class GnarledStaff : BaseStaff
+    {
+        [Constructable]
+        public GnarledStaff()
+            : base(0x13F8)
+        {
+            this.Weight = 3.0;
+        }
+
+        public GnarledStaff(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ForceOfNature;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 50;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/GreaterHealWand.cs

@@ -0,0 +1,38 @@
+using System;
+using Server.Spells.Fourth;
+
+namespace Server.Items
+{
+    public class GreaterHealWand : BaseWand
+    {
+        [Constructable]
+        public GreaterHealWand()
+            : base(WandEffect.GreaterHealing, 1, Core.ML ? 109 : 5)
+        {
+        }
+
+        public GreaterHealWand(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnWandUse(Mobile from)
+        {
+            this.Cast(new GreaterHealSpell(from, this));
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Halberd.cs

@@ -0,0 +1,127 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(GargishTalwar))]
+    [FlipableAttribute(0x143E, 0x143F)]
+    public class Halberd : BasePoleArm
+    {
+        [Constructable]
+        public Halberd()
+            : base(0x143E)
+        {
+            this.Weight = 16.0;
+        }
+
+        public Halberd(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.WhirlwindAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 95;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 21;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 4.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 49;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 80;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/HammerPick.cs

@@ -0,0 +1,128 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DiscMace))]
+    [FlipableAttribute(0x143D, 0x143C)]
+    public class HammerPick : BaseBashing
+    {
+        [Constructable]
+        public HammerPick()
+            : base(0x143D)
+        {
+            Weight = 9.0;
+            Layer = Layer.OneHanded;
+        }
+
+        public HammerPick(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ArmorIgnore;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MortalStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 28;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/HarmWand.cs

@@ -0,0 +1,38 @@
+using System;
+using Server.Spells.Second;
+
+namespace Server.Items
+{
+    public class HarmWand : BaseWand
+    {
+        [Constructable]
+        public HarmWand()
+            : base(WandEffect.Harming, 5, Core.ML ? 109 : 30)
+        {
+        }
+
+        public HarmWand(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnWandUse(Mobile from)
+        {
+            this.Cast(new HarmSpell(from, this));
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Hatchet.cs

@@ -0,0 +1,128 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefTinkering), typeof(DualShortAxes))]
+    [FlipableAttribute(0xF43, 0xF44)]
+    public class Hatchet : BaseAxe
+    {
+        [Constructable]
+        public Hatchet()
+            : base(0xF43)
+        {
+            this.Weight = 4.0;
+        }
+
+        public Hatchet(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ArmorIgnore;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Disarm;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 41;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 80;
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/HealWand.cs

@@ -0,0 +1,38 @@
+using System;
+using Server.Spells.First;
+
+namespace Server.Items
+{
+    public class HealWand : BaseWand
+    {
+        [Constructable]
+        public HealWand()
+            : base(WandEffect.Healing, 10, Core.ML ? 109 : 25)
+        {
+        }
+
+        public HealWand(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnWandUse(Mobile from)
+        {
+            this.Cast(new HealSpell(from, this));
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/HeavyCrossbow.cs

@@ -0,0 +1,154 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x13FD, 0x13FC)]
+    public class HeavyCrossbow : BaseRanged
+    {
+        [Constructable]
+        public HeavyCrossbow()
+            : base(0x13FD)
+        {
+            this.Weight = 9.0;
+            this.Layer = Layer.TwoHanded;
+        }
+
+        public HeavyCrossbow(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int EffectID
+        {
+            get
+            {
+                return 0x1BFE;
+            }
+        }
+        public override Type AmmoType
+        {
+            get
+            {
+                return typeof(Bolt);
+            }
+        }
+        public override Item Ammo
+        {
+            get
+            {
+                return new Bolt();
+            }
+        }
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.MovingShot;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Dismount;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 80;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return Core.ML ? 20 : 20;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return Core.ML ? 24 : 24;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 22;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 5.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 56;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int DefMaxRange
+        {
+            get
+            {
+                return 8;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 100;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/HeavyOrnateAxe.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace Server.Items
+{
+    public class HeavyOrnateAxe : OrnateAxe
+    {
+        [Constructable]
+        public HeavyOrnateAxe()
+        {
+            this.Attributes.WeaponDamage = 8;
+        }
+
+        public HeavyOrnateAxe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1073548;
+            }
+        }// heavy ornate axe
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/HitLower.cs

@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Generic;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class HitLower
+    {
+        public static readonly TimeSpan AttackEffectDuration = TimeSpan.FromSeconds(10.0);
+        public static readonly TimeSpan DefenseEffectDuration = TimeSpan.FromSeconds(8.0);
+        private static readonly Dictionary<Mobile, AttackTimer> m_AttackTable = new Dictionary<Mobile, AttackTimer>();
+        private static readonly Dictionary<Mobile, DefenseTimer> m_DefenseTable = new Dictionary<Mobile, DefenseTimer>();
+
+        public static bool IsUnderAttackEffect(Mobile m)
+        {
+            return m_AttackTable.ContainsKey(m);
+        }
+
+        public static bool ApplyAttack(Mobile m)
+        {
+            if (IsUnderAttackEffect(m))
+                return false;
+
+            m_AttackTable[m] = new AttackTimer(m);
+            BuffInfo.AddBuff(m, new BuffInfo(BuffIcon.HitLowerAttack, 1151315, 1151314, AttackEffectDuration, m, "25"));
+            m.SendLocalizedMessage(1062319); // Your attack chance has been reduced!
+
+            m.Delta(MobileDelta.WeaponDamage);
+
+            return true;
+        }
+
+        public static bool IsUnderDefenseEffect(Mobile m)
+        {
+            return m_DefenseTable.ContainsKey(m);
+        }
+
+        public static bool ApplyDefense(Mobile m)
+        {
+            if (!Core.HS)
+            {
+                if (IsUnderDefenseEffect(m))
+                    return false;
+
+                m_DefenseTable[m] = new DefenseTimer(m, 25);
+                BuffInfo.AddBuff(m, new BuffInfo(BuffIcon.HitLowerDefense, 1151313, 1151286, DefenseEffectDuration, m, "35"));
+                m.SendLocalizedMessage(1062318); // Your defense chance has been reduced!
+
+                m.Delta(MobileDelta.WeaponDamage);
+
+                return true;
+            }
+            else
+            {
+                if (m_DefenseTable.ContainsKey(m))
+                {
+                    var timer = m_DefenseTable[m];
+
+                    if (timer != null)
+                    {
+                        timer.Stop();
+                        timer.DefenseMalus = 0;
+                    }
+                }
+
+                int malus;
+
+                if (m is PlayerMobile)
+                {
+                    malus = 45 + BaseArmor.GetRefinedDefenseChance(m);
+                    malus = malus - (int)((double)malus * .35);
+                }
+                else
+                {
+                    malus = 25;
+                }
+
+                m_DefenseTable[m] = new DefenseTimer(m, malus);
+                BuffInfo.AddBuff(m, new BuffInfo(BuffIcon.HitLowerDefense, 1151313, 1151286, DefenseEffectDuration, m, malus.ToString()));
+                m.SendLocalizedMessage(1062318); // Your defense chance has been reduced!
+
+                m.Delta(MobileDelta.WeaponDamage);
+
+                return true;
+            }
+        }
+
+        private static void RemoveAttack(Mobile m)
+        {
+            if (m_AttackTable.ContainsKey(m))
+            {
+                m_AttackTable.Remove(m);
+                m.SendLocalizedMessage(1062320); // Your attack chance has returned to normal.
+            }
+        }
+
+        private static void RemoveDefense(Mobile m)
+        {
+            if (m_DefenseTable.ContainsKey(m))
+            {
+                m_DefenseTable.Remove(m);
+                m.SendLocalizedMessage(1062321); // Your defense chance has returned to normal.
+
+                m.Delta(MobileDelta.WeaponDamage);
+            }
+        }
+
+        public static int GetDefenseMalus(Mobile m)
+        {
+            if (m_DefenseTable.ContainsKey(m))
+            {
+                return m_DefenseTable[m].DefenseMalus;
+            }
+
+            return 0;
+        }
+
+        private class AttackTimer : Timer
+        {
+            private readonly Mobile m_Player;
+
+            public AttackTimer(Mobile player)
+                : base(AttackEffectDuration)
+            {
+                m_Player = player;
+
+                Priority = TimerPriority.TwoFiftyMS;
+
+                Start();
+            }
+
+            protected override void OnTick()
+            {
+                RemoveAttack(m_Player);
+            }
+        }
+
+        private class DefenseTimer : Timer
+        {
+            private readonly Mobile m_Player;
+            public int DefenseMalus { get; set; }
+
+            public DefenseTimer(Mobile player, int malus)
+                : base(DefenseEffectDuration)
+            {
+                m_Player = player;
+                DefenseMalus = malus;
+
+                Priority = TimerPriority.TwoFiftyMS;
+                Start();
+            }
+
+            protected override void OnTick()
+            {
+                RemoveDefense(m_Player);
+            }
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/IDWand.cs

@@ -0,0 +1,52 @@
+using System;
+
+namespace Server.Items
+{
+    public class IDWand : BaseWand
+    {
+        [Constructable]
+        public IDWand()
+            : base(WandEffect.Identification, 25, 175)
+        {
+        }
+
+        public IDWand(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override TimeSpan GetUseDelay
+        {
+            get
+            {
+                return TimeSpan.Zero;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override bool OnWandTarget(Mobile from, object o)
+        {
+            if (o is BaseWeapon)
+                ((BaseWeapon)o).Identified = true;
+            else if (o is BaseArmor)
+                ((BaseArmor)o).Identified = true;
+
+            if (!Core.AOS && o is Item)
+                ((Item)o).OnSingleClick(from);
+
+            return (o is Item);
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/JukaBow.cs

@@ -0,0 +1,98 @@
+using System;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x13B2, 0x13B1)]
+    public class JukaBow : Bow
+    {
+        [Constructable]
+        public JukaBow()
+        { }
+
+        public JukaBow(Serial serial)
+            : base(serial)
+        { }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool IsModified => Slayer != SlayerName.None;
+        public override int AosStrengthReq => 80;
+        public override int AosDexterityReq => 80;
+        public override int OldStrengthReq => 80;
+        public override int OldDexterityReq => 80;
+
+        public override bool CanEquip(Mobile from)
+        {
+            if (IsModified)
+            {
+                return base.CanEquip(from);
+            }
+
+            from.SendMessage("You cannot equip this bow until a bowyer modifies it.");
+            return false;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsModified)
+            {
+                from.SendMessage("That has already been modified.");
+            }
+            else if (!IsChildOf(from.Backpack))
+            {
+                from.SendMessage("This must be in your backpack to modify it.");
+            }
+            else if (from.Skills[SkillName.Fletching].Base < 100.0)
+            {
+                from.SendMessage("Only a grandmaster bowcrafter can modify this weapon.");
+            }
+            else
+            {
+                from.BeginTarget(2, false, Targeting.TargetFlags.None, new TargetCallback(OnTargetGears));
+                from.SendMessage("Select the gears you wish to use.");
+            }
+        }
+
+        public void OnTargetGears(Mobile from, object targ)
+        {
+            Gears g = targ as Gears;
+
+            if (g == null || !g.IsChildOf(from.Backpack))
+            {
+                from.SendMessage("Those are not gears."); // Apparently gears that aren't in your backpack aren't really gears at all. :-(
+            }
+            else if (IsModified)
+            {
+                from.SendMessage("That has already been modified.");
+            }
+            else if (!IsChildOf(from.Backpack))
+            {
+                from.SendMessage("This must be in your backpack to modify it.");
+            }
+            else if (from.Skills[SkillName.Fletching].Base < 100.0)
+            {
+                from.SendMessage("Only a grandmaster bowcrafter can modify this weapon.");
+            }
+            else
+            {
+                g.Consume();
+
+                Hue = 0x453;
+                Slayer = (SlayerName)Utility.Random(2, 25);
+
+                from.SendMessage("You modify it.");
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Kama.cs

@@ -0,0 +1,163 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DualPointedSpear))]
+    [FlipableAttribute(0x27AD, 0x27F8)]
+    public class Kama : BaseKnife
+    {
+        [Constructable]
+        public Kama()
+            : base(0x27AD)
+        {
+            this.Weight = 7.0;
+            this.Layer = Layer.TwoHanded;
+        }
+
+        public Kama(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.WhirlwindAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DefenseMastery;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 55;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 9;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 55;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x232;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 60;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Piercing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Pierce1H;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Katana.cs

@@ -0,0 +1,141 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(GargishKatana))]
+    [FlipableAttribute(0x13FF, 0x13FE)]
+    public class Katana : BaseSword
+    {
+        [Constructable]
+        public Katana()
+            : base(0x13FF)
+        {
+            this.Weight = 6.0;
+        }
+
+        public Katana(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DoubleStrike;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ArmorIgnore;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 46;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 26;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 58;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23B;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 90;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Kryss.cs

@@ -0,0 +1,160 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(GargishKryss))]
+    [FlipableAttribute(0x1401, 0x1400)]
+    public class Kryss : BaseSword
+    {
+        [Constructable]
+        public Kryss()
+            : base(0x1401)
+        {
+            Weight = 2.0;
+        }
+
+        public Kryss(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ArmorIgnore;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.InfectiousStrike;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 12;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 53;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.00f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 3;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 28;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 53;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23C;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 90;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Piercing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Pierce1H;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Lajatang.cs

@@ -0,0 +1,163 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DualPointedSpear))]
+    [FlipableAttribute(0x27A7, 0x27F2)]
+    public class Lajatang : BaseKnife
+    {
+        [Constructable]
+        public Lajatang()
+            : base(0x27A7)
+        {
+            this.Weight = 12.0;
+            this.Layer = Layer.TwoHanded;
+        }
+
+        public Lajatang(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.DefenseMastery;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.FrenziedWhirlwind;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 65;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 19;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 32;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 65;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 55;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x232;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 90;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 95;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Piercing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Pierce1H;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Lance.cs

@@ -0,0 +1,162 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(GargishLance))]
+    [FlipableAttribute(0x26C0, 0x26CA)]
+    public class Lance : BaseSword
+    {
+        [Constructable]
+        public Lance()
+            : base(0x26C0)
+        {
+            this.Weight = 12.0;
+        }
+
+        public Lance(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Dismount;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 95;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 22;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 24;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 4.25f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 95;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 24;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x23C;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x238;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override WeaponType DefType
+        {
+            get
+            {
+                return WeaponType.Piercing;
+            }
+        }
+        public override WeaponAnimation DefAnimation
+        {
+            get
+            {
+                return WeaponAnimation.Pierce1H;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/LargeBattleAxe.cs

@@ -0,0 +1,127 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DualShortAxes))]
+    [FlipableAttribute(0x13FB, 0x13FA)]
+    public class LargeBattleAxe : BaseAxe
+    {
+        [Constructable]
+        public LargeBattleAxe()
+            : base(0x13FB)
+        {
+            this.Weight = 6.0;
+        }
+
+        public LargeBattleAxe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.WhirlwindAttack;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.BleedAttack;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 80;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 17;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 29;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 38;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Leafblade.cs

@@ -0,0 +1,141 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(BloodBlade))]
+    [FlipableAttribute(0x2D22, 0x2D2E)]
+    public class Leafblade : BaseKnife
+    {
+        [Constructable]
+        public Leafblade()
+            : base(0x2D22)
+        {
+            this.Weight = 8.0;
+        }
+
+        public Leafblade(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Feint;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ArmorIgnore;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 42;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 13;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 42;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x239;
+            }
+        }
+        public override SkillName DefSkill
+        {
+            get
+            {
+                return SkillName.Fencing;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 30;
+            }
+        }// TODO
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 60;
+            }
+        }// TODO
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/LightningWand.cs

@@ -0,0 +1,38 @@
+using System;
+using Server.Spells.Fourth;
+
+namespace Server.Items
+{
+    public class LightningWand : BaseWand
+    {
+        [Constructable]
+        public LightningWand()
+            : base(WandEffect.Lightning, 5, Core.ML ? 109 : 20)
+        {
+        }
+
+        public LightningWand(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnWandUse(Mobile from)
+        {
+            this.Cast(new LightningSpell(from, this));
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/LightweightShortbow.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace Server.Items
+{
+    public class LightweightShortbow : MagicalShortbow
+    {
+        [Constructable]
+        public LightweightShortbow()
+        {
+            this.Balanced = true;
+        }
+
+        public LightweightShortbow(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1073510;
+            }
+        }// lightweight shortbow
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Longsword.cs

@@ -0,0 +1,141 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DreadSword))]
+    [FlipableAttribute(0xF61, 0xF60)]
+    public class Longsword : BaseSword
+    {
+        [Constructable]
+        public Longsword()
+            : base(0xF61)
+        {
+            this.Weight = 7.0;
+        }
+
+        public Longsword(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ArmorIgnore;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 14;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 18;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 3.50f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 25;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 33;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int DefHitSound
+        {
+            get
+            {
+                return 0x237;
+            }
+        }
+        public override int DefMissSound
+        {
+            get
+            {
+                return 0x23A;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/Mace.cs

@@ -0,0 +1,127 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefBlacksmithy), typeof(DiscMace))]
+    [FlipableAttribute(0xF5C, 0xF5D)]
+    public class Mace : BaseBashing
+    {
+        [Constructable]
+        public Mace()
+            : base(0xF5C)
+        {
+            this.Weight = 14.0;
+        }
+
+        public Mace(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.ConcussionBlow;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Disarm;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 45;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 15;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 8;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 32;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 30;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 70;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/MagicArrowWand.cs

@@ -0,0 +1,38 @@
+using System;
+using Server.Spells.First;
+
+namespace Server.Items
+{
+    public class MagicArrowWand : BaseWand
+    {
+        [Constructable]
+        public MagicArrowWand()
+            : base(WandEffect.MagicArrow, 5, Core.ML ? 109 : 30)
+        {
+        }
+
+        public MagicArrowWand(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        public override void OnWandUse(Mobile from)
+        {
+            this.Cast(new MagicArrowSpell(from, this));
+        }
+    }
+}

Scripts/Items/Equipment/Weapons/MagicWand.cs

@@ -0,0 +1,127 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    public class MagicWand : BaseBashing, IRepairable
+    {
+        public CraftSystem RepairSystem { get { return DefCarpentry.CraftSystem; } }
+
+        [Constructable]
+        public MagicWand()
+            : base(0xDF2)
+        {
+            this.Weight = 1.0;
+        }
+
+        public MagicWand(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override WeaponAbility PrimaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Dismount;
+            }
+        }
+        public override WeaponAbility SecondaryAbility
+        {
+            get
+            {
+                return WeaponAbility.Disarm;
+            }
+        }
+        public override int AosStrengthReq
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int AosMinDamage
+        {
+            get
+            {
+                return 9;
+            }
+        }
+        public override int AosMaxDamage
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override int AosSpeed
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override float MlSpeed
+        {
+            get
+            {
+                return 2.75f;
+            }
+        }
+        public override int OldStrengthReq
+        {
+            get
+            {
+                return 0;
+            }
+        }
+        public override int OldMinDamage
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override int OldMaxDamage
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public override int OldSpeed
+        {
+            get
+            {
+                return 35;
+            }
+        }
+        public override int InitMinHits
+        {
+            get
+            {
+                return 31;
+            }
+        }
+        public override int InitMaxHits
+        {
+            get
+            {
+                return 110;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}