#W# Source and Scripts added. Added Scripts/Settings.cs to expose some basic tweak able settings.

Scripts/Items/Weapons/Abilities/ArmorIgnore.cs

@@ -0,0 +1,33 @@
+using System;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// This special move allows the skilled warrior to bypass his target's physical resistance, for one shot only.
+	/// The Armor Ignore shot does slightly less damage than normal.
+	/// Against a heavily armored opponent, this ability is a big win, but when used against a very lightly armored foe, it might be better to use a standard strike!
+	/// </summary>
+	public class ArmorIgnore : WeaponAbility
+	{
+		public ArmorIgnore()
+		{
+		}
+
+		public override int BaseMana{ get{ return 30; } }
+		public override double DamageScalar{ get{ return 0.9; } }
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if ( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1060076 ); // Your attack penetrates their armor!
+			defender.SendLocalizedMessage( 1060077 ); // The blow penetrated your armor!
+
+			defender.PlaySound( 0x56 );
+			defender.FixedParticles( 0x3728, 200, 25, 9942, EffectLayer.Waist );
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/ArmorPierce.cs

@@ -0,0 +1,44 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// Strike your opponent with great force, partially bypassing their armor and inflicting greater damage. Requires either Bushido or Ninjitsu skill
+	/// </summary>
+	public class ArmorPierce : WeaponAbility
+	{
+		public ArmorPierce()
+		{
+		}
+
+		public override bool CheckSkills( Mobile from )
+		{
+			if( GetSkill( from, SkillName.Ninjitsu ) < 50.0  && GetSkill( from, SkillName.Bushido ) < 50.0 )
+			{
+				from.SendLocalizedMessage( 1063347, "50" ); // You need ~1_SKILL_REQUIREMENT~ Bushido or Ninjitsu skill to perform that attack!
+				return false;
+			}
+
+			return base.CheckSkills( from );
+		}
+
+		public override int BaseMana{ get{ return 30; } }
+		public override double DamageScalar{ get{ return 1.5; } }
+
+		public override bool RequiresSE { get { return true; } }
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if ( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1063350 ); // You pierce your opponent's armor!
+			defender.SendLocalizedMessage( 1063351 ); // Your attacker pierced your armor!
+
+			defender.FixedParticles( 0x3728, 1, 26, 0x26D6, 0, 0, EffectLayer.Waist );
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/BleedAttack.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections;
+using Server.Mobiles;
+using Server.Spells.Necromancy;
+using Server.Network;
+using Server.Spells;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// Make your opponent bleed profusely with this wicked use of your weapon.
+	/// When successful, the target will bleed for several seconds, taking damage as time passes for up to ten seconds.
+	/// The rate of damage slows down as time passes, and the blood loss can be completely staunched with the use of bandages. 
+	/// </summary>
+	public class BleedAttack : WeaponAbility
+	{
+		public BleedAttack()
+		{
+		}
+
+		public override int BaseMana{ get{ return 30; } }
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if ( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			// Necromancers under Lich or Wraith Form are immune to Bleed Attacks.
+			TransformContext context = TransformationSpellHelper.GetContext( defender );
+
+			if ( (context != null && ( context.Type == typeof( LichFormSpell ) || context.Type == typeof( WraithFormSpell ))) ||
+				(defender is BaseCreature && ((BaseCreature)defender).BleedImmune) )
+			{
+				attacker.SendLocalizedMessage( 1062052 ); // Your target is not affected by the bleed attack!
+				return;
+			}
+
+			attacker.SendLocalizedMessage( 1060159 ); // Your target is bleeding!
+			defender.SendLocalizedMessage( 1060160 ); // You are bleeding!
+
+			if ( defender is PlayerMobile )
+			{
+				defender.LocalOverheadMessage( MessageType.Regular, 0x21, 1060757 ); // You are bleeding profusely
+				defender.NonlocalOverheadMessage( MessageType.Regular, 0x21, 1060758, defender.Name ); // ~1_NAME~ is bleeding profusely
+			}
+
+			defender.PlaySound( 0x133 );
+			defender.FixedParticles( 0x377A, 244, 25, 9950, 31, 0, EffectLayer.Waist );
+
+			BeginBleed( defender, attacker );
+		}
+
+		private static Hashtable m_Table = new Hashtable();
+
+		public static bool IsBleeding( Mobile m )
+		{
+			return m_Table.Contains( m );
+		}
+
+		public static void BeginBleed( Mobile m, Mobile from )
+		{
+			Timer t = (Timer)m_Table[m];
+
+			if ( t != null )
+				t.Stop();
+
+			t = new InternalTimer( from, m );
+			m_Table[m] = t;
+
+			t.Start();
+		}
+
+		public static void DoBleed( Mobile m, Mobile from, int level )
+		{
+			if ( m.Alive )
+			{
+				int damage = Utility.RandomMinMax( level, level * 2 );
+
+				if ( !m.Player )
+					damage *= 2;
+
+				m.PlaySound( 0x133 );
+				m.Damage( damage, from );
+
+				Blood blood = new Blood();
+
+				blood.ItemID = Utility.Random( 0x122A, 5 );
+
+				blood.MoveToWorld( m.Location, m.Map );
+			}
+			else
+			{
+				EndBleed( m, false );
+			}
+		}
+
+		public static void EndBleed( Mobile m, bool message )
+		{
+			Timer t = (Timer)m_Table[m];
+
+			if ( t == null )
+				return;
+
+			t.Stop();
+			m_Table.Remove( m );
+
+			if ( message )
+				m.SendLocalizedMessage( 1060167 ); // The bleeding wounds have healed, you are no longer bleeding!
+		}
+
+		private class InternalTimer : Timer
+		{
+			private Mobile m_From;
+			private Mobile m_Mobile;
+			private int m_Count;
+
+			public InternalTimer( Mobile from, Mobile m ) : base( TimeSpan.FromSeconds( 2.0 ), TimeSpan.FromSeconds( 2.0 ) )
+			{
+				m_From = from;
+				m_Mobile = m;
+				Priority = TimerPriority.TwoFiftyMS;
+			}
+
+			protected override void OnTick()
+			{
+				DoBleed( m_Mobile, m_From, 5 - m_Count );
+
+				if ( ++m_Count == 5 )
+					EndBleed( m_Mobile, true );
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/Block.cs

@@ -0,0 +1,111 @@
+using System;
+using Server;
+using System.Collections;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// Raises your defenses for a short time. Requires Bushido or Ninjitsu skill.
+	/// </summary>
+	public class Block : WeaponAbility
+	{
+		public Block()
+		{
+		}
+
+		public override int BaseMana{ get{ return 30; } }
+
+		public override bool CheckSkills( Mobile from )
+		{
+			if( GetSkill( from, SkillName.Ninjitsu ) < 50.0  && GetSkill( from, SkillName.Bushido ) < 50.0 )
+			{
+				from.SendLocalizedMessage( 1063347, "50" ); // You need ~1_SKILL_REQUIREMENT~ Bushido or Ninjitsu skill to perform that attack!
+				return false;
+			}
+
+			return base.CheckSkills( from );
+		}
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if ( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1063345 ); // You block an attack!
+			defender.SendLocalizedMessage( 1063346 ); // Your attack was blocked!
+
+			attacker.FixedParticles( 0x37C4, 1, 16, 0x251D, 0x39D, 0x3, EffectLayer.RightHand );
+
+			int bonus = (int)(10.0 * ((Math.Max( attacker.Skills[SkillName.Bushido].Value, attacker.Skills[SkillName.Ninjitsu].Value ) - 50.0) / 70.0 + 5));
+
+			BeginBlock( attacker, bonus );
+		}
+
+		private class BlockInfo
+		{
+			public Mobile m_Target;
+			public Timer m_Timer;
+			public int m_Bonus;
+
+			public BlockInfo( Mobile target, int bonus )
+			{
+				m_Target = target;
+				m_Bonus = bonus;
+			}
+		}
+
+		private static Hashtable m_Table = new Hashtable();
+
+		public static bool GetBonus( Mobile targ, ref int bonus )
+		{
+			BlockInfo info = m_Table[targ] as BlockInfo;
+
+			if ( info == null )
+				return false;
+
+			bonus = info.m_Bonus;
+			return true;
+		}
+
+		public static void BeginBlock( Mobile m, int bonus )
+		{
+			EndBlock( m );
+
+			BlockInfo info = new BlockInfo( m, bonus );
+			info.m_Timer = new InternalTimer( m );
+
+			m_Table[m] = info;
+		}
+
+		public static void EndBlock( Mobile m )
+		{
+			BlockInfo info = m_Table[m] as BlockInfo;
+
+			if ( info != null )
+			{
+				if ( info.m_Timer != null )
+					info.m_Timer.Stop();
+
+				m_Table.Remove( m );
+			}
+		}
+
+		private class InternalTimer : Timer
+		{
+			private Mobile m_Mobile;
+
+			public InternalTimer( Mobile m ) : base( TimeSpan.FromSeconds( 6.0 ) )
+			{
+				m_Mobile = m;
+				Priority = TimerPriority.TwoFiftyMS;
+			}
+
+			protected override void OnTick()
+			{
+				EndBlock( m_Mobile );
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/ConcussionBlow.cs

@@ -0,0 +1,52 @@
+using System;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// This devastating strike is most effective against those who are in good health and whose reserves of mana are low, or vice versa.
+	/// </summary>
+	public class ConcussionBlow : WeaponAbility
+	{
+		public ConcussionBlow()
+		{
+		}
+
+		public override int BaseMana{ get{ return 25; } }
+
+		public override bool OnBeforeDamage( Mobile attacker, Mobile defender )
+		{
+			if ( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return false;
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1060165 ); // You have delivered a concussion!
+			defender.SendLocalizedMessage( 1060166 ); // You feel disoriented!
+
+			defender.PlaySound( 0x213 );
+			defender.FixedParticles( 0x377A, 1, 32, 9949, 1153, 0, EffectLayer.Head );
+
+			Effects.SendMovingParticles( new Entity( Serial.Zero, new Point3D( defender.X, defender.Y, defender.Z + 10 ), defender.Map ), new Entity( Serial.Zero, new Point3D( defender.X, defender.Y, defender.Z + 20 ), defender.Map ), 0x36FE, 1, 0, false, false, 1133, 3, 9501, 1, 0, EffectLayer.Waist, 0x100 );
+
+			int damage = 10; // Base damage is 10.
+
+			if ( defender.HitsMax > 0 ) 
+			{
+				double hitsPercent = ( (double)defender.Hits / (double)defender.HitsMax ) * 100.0;
+
+				double manaPercent = 0;
+
+				if ( defender.ManaMax > 0 )
+					manaPercent = ( (double)defender.Mana / (double)defender.ManaMax ) * 100.0;
+
+				damage += Math.Min( (int)(Math.Abs( hitsPercent - manaPercent ) / 4), 20 );
+			}
+
+			// Total damage is 10 + (0~20) = 10~30, physical, non-resistable.
+
+			defender.Damage( damage, attacker );
+
+			return true;
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/CrushingBlow.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// Also known as the Haymaker, this attack dramatically increases the damage done by a weapon reaching its mark.
+	/// </summary>
+	public class CrushingBlow : WeaponAbility
+	{
+		public CrushingBlow()
+		{
+		}
+
+		public override int BaseMana{ get{ return 25; } }
+		public override double DamageScalar{ get{ return 1.5; } }
+
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if ( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1060090 ); // You have delivered a crushing blow!
+			defender.SendLocalizedMessage( 1060091 ); // You take extra damage from the crushing attack!
+
+			defender.PlaySound( 0x1E1 );
+			defender.FixedParticles( 0, 1, 0, 9946, EffectLayer.Head );
+
+			Effects.SendMovingParticles( new Entity( Serial.Zero, new Point3D( defender.X, defender.Y, defender.Z + 50 ), defender.Map ), new Entity( Serial.Zero, new Point3D( defender.X, defender.Y, defender.Z + 20 ), defender.Map ), 0xFB4, 1, 0, false, false, 0, 3, 9501, 1, 0, EffectLayer.Head, 0x100 );
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/DefenseMastery.cs

@@ -0,0 +1,103 @@
+using System;
+using Server;
+using System.Collections;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// Raises your physical resistance for a short time while lowering your ability to inflict damage. Requires Bushido or Ninjitsu skill.
+	/// </summary>
+	public class DefenseMastery : WeaponAbility
+	{
+		public DefenseMastery()
+		{
+		}
+
+		public override bool CheckSkills( Mobile from )
+		{
+			if( GetSkill( from, SkillName.Ninjitsu ) < 50.0  && GetSkill( from, SkillName.Bushido ) < 50.0 )
+			{
+				from.SendLocalizedMessage( 1063347, "50" ); // You need ~1_SKILL_REQUIREMENT~ Bushido or Ninjitsu skill to perform that attack!
+				return false;
+			}
+
+			return base.CheckSkills( from );
+		}
+
+		public override int BaseMana { get { return 30; } }
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1063353 ); // You perform a masterful defense!
+
+			attacker.FixedParticles( 0x375A, 1, 17, 0x7F2, 0x3E8, 0x3, EffectLayer.Waist );
+
+			int modifier = (int)(30.0 * ((Math.Max( attacker.Skills[SkillName.Bushido].Value, attacker.Skills[SkillName.Ninjitsu].Value ) - 50.0) / 70.0));
+
+			DefenseMasteryInfo info = m_Table[attacker] as DefenseMasteryInfo;
+
+			if( info != null )
+				EndDefense( (object)info );
+
+			ResistanceMod mod = new ResistanceMod( ResistanceType.Physical, 50 + modifier );
+			attacker.AddResistanceMod( mod );
+
+			info = new DefenseMasteryInfo( attacker, 80 - modifier, mod );
+			info.m_Timer = Timer.DelayCall( TimeSpan.FromSeconds( 3.0 ), new TimerStateCallback( EndDefense ), info );
+
+			m_Table[attacker] = info;
+
+			attacker.Delta( MobileDelta.WeaponDamage );
+		}
+
+		private class DefenseMasteryInfo
+		{
+			public Mobile m_From;
+			public Timer m_Timer;
+			public int m_DamageMalus;
+			public ResistanceMod m_Mod;
+
+			public DefenseMasteryInfo( Mobile from, int damageMalus, ResistanceMod mod )
+			{
+				m_From = from;
+				m_DamageMalus = damageMalus;
+				m_Mod = mod;
+			}
+		}
+
+		private static Hashtable m_Table = new Hashtable();
+
+		public static bool GetMalus( Mobile targ, ref int damageMalus )
+		{
+			DefenseMasteryInfo info = m_Table[targ] as DefenseMasteryInfo;
+
+			if( info == null )
+				return false;
+
+			damageMalus = info.m_DamageMalus;
+			return true;
+		}
+
+		private static void EndDefense( object state )
+		{
+			DefenseMasteryInfo info = (DefenseMasteryInfo)state;
+
+			if( info.m_Mod != null )
+				info.m_From.RemoveResistanceMod( info.m_Mod );
+
+			if( info.m_Timer != null )
+				info.m_Timer.Stop();
+
+			// No message is sent to the player.
+
+			m_Table.Remove( info.m_From );
+
+			info.m_From.Delta( MobileDelta.WeaponDamage );
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/Disarm.cs

@@ -0,0 +1,84 @@
+using System;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// This attack allows you to disarm your foe.
+	/// Now in Age of Shadows, a successful Disarm leaves the victim unable to re-arm another weapon for several seconds.
+	/// </summary>
+	public class Disarm : WeaponAbility
+	{
+		public Disarm()
+		{
+		}
+
+		public override int BaseMana{ get{ return 20; } }
+
+		// No longer active in pub21:
+		/*public override bool CheckSkills( Mobile from )
+		{
+			if ( !base.CheckSkills( from ) )
+				return false;
+
+			if ( !(from.Weapon is Fists) )
+				return true;
+
+			Skill skill = from.Skills[SkillName.ArmsLore];
+
+			if ( skill != null && skill.Base >= 80.0 )
+				return true;
+
+			from.SendLocalizedMessage( 1061812 ); // You lack the required skill in armslore to perform that attack!
+
+			return false;
+		}*/
+
+		public override bool RequiresTactics( Mobile from )
+		{
+			BaseWeapon weapon = from.Weapon as BaseWeapon;
+
+			if ( weapon == null )
+				return false;
+
+			return weapon.Skill != SkillName.Wrestling;
+		}
+
+		public static readonly TimeSpan BlockEquipDuration = TimeSpan.FromSeconds( 5.0 );
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if ( !Validate( attacker ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			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 (toDisarm == null || toDisarm is BaseShield || toDisarm is Spellbook && !Core.ML )
+			{
+				attacker.SendLocalizedMessage( 1060849 ); // Your target is already unarmed!
+			}
+			else if ( CheckMana( attacker, true ) )
+			{
+				attacker.SendLocalizedMessage( 1060092 ); // You disarm their weapon!
+				defender.SendLocalizedMessage( 1060093 ); // Your weapon has been disarmed!
+
+				defender.PlaySound( 0x3B9 );
+				defender.FixedParticles( 0x37BE, 232, 25, 9948, EffectLayer.LeftHand );
+
+				pack.DropItem( toDisarm );
+
+				BaseWeapon.BlockEquip( defender, BlockEquipDuration );
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/Dismount.cs

@@ -0,0 +1,113 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// Perfect for the foot-soldier, the Dismount special attack can unseat a mounted opponent.
+	/// The fighter using this ability must be on his own two feet and not in the saddle of a steed
+	/// (with one exception: players may use a lance to dismount other players while mounted).
+	/// If it works, the target will be knocked off his own mount and will take some extra damage from the fall!
+	/// </summary>
+	public class Dismount : WeaponAbility
+	{
+		public Dismount()
+		{
+		}
+
+		public override int BaseMana{ get{ return 20; } }
+
+		public override bool Validate( Mobile from )
+		{
+			if ( !base.Validate( from ) )
+				return false;
+
+			if ( from.Mounted && !(from.Weapon is Lance) )
+			{
+				from.SendLocalizedMessage( 1061283 ); // You cannot perform that attack while mounted!
+				return false;
+			}
+
+			return true;
+		}
+
+		public static readonly TimeSpan RemountDelay = TimeSpan.FromSeconds( 10.0 ); 
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if ( !Validate( attacker ) )
+				return;
+
+			if ( defender is ChaosDragoon || defender is ChaosDragoonElite )
+				return;
+
+			if ( attacker.Mounted && ( !(attacker.Weapon is Lance) || !(defender.Weapon is Lance) ) ) // TODO: Should there be a message here?
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			IMount mount = defender.Mount;
+
+			if (mount == null && !Server.Spells.Ninjitsu.AnimalForm.UnderTransformation( defender ) )
+			{
+				attacker.SendLocalizedMessage( 1060848 ); // This attack only works on mounted targets
+				return;
+			}
+
+			if ( !CheckMana( attacker, true ) )
+				return;
+
+			if ( Core.ML && attacker is LesserHiryu && 0.8 >= Utility.RandomDouble() )
+			{
+				return; //Lesser Hiryu have an 80% chance of missing this attack
+			}
+
+			attacker.SendLocalizedMessage( 1060082 ); // The force of your attack has dislodged them from their mount!
+
+			if ( attacker.Mounted )
+				defender.SendLocalizedMessage( 1062315 ); // You fall off your mount!
+			else
+				defender.SendLocalizedMessage( 1060083 ); // You fall off of your mount and take damage!
+
+			defender.PlaySound( 0x140 );
+			defender.FixedParticles( 0x3728, 10, 15, 9955, EffectLayer.Waist );
+
+			if (defender is PlayerMobile)
+			{
+				if (Server.Spells.Ninjitsu.AnimalForm.UnderTransformation(defender))
+				{
+					defender.SendLocalizedMessage(1114066, attacker.Name); // ~1_NAME~ knocked you out of animal form!
+				}
+				else if (defender.Mounted)
+				{
+					defender.SendLocalizedMessage(1040023); // You have been knocked off of your mount!
+				}
+
+				(defender as PlayerMobile).SetMountBlock(BlockMountType.Dazed, TimeSpan.FromSeconds(10), true);
+			}
+			else
+			{
+				defender.Mount.Rider = null;
+			}
+
+			if( attacker is PlayerMobile )
+			{
+				(attacker as PlayerMobile).SetMountBlock(BlockMountType.DismountRecovery, RemountDelay, true );
+			}
+			else if( Core.ML && attacker is BaseCreature )
+			{
+				BaseCreature bc = attacker as BaseCreature;
+
+				if( bc.ControlMaster is PlayerMobile )
+				{
+					PlayerMobile pm = bc.ControlMaster as PlayerMobile;
+
+					pm.SetMountBlock(BlockMountType.DismountRecovery, RemountDelay, false );
+				}
+			}
+				
+			if ( !attacker.Mounted )
+				AOS.Damage( defender, attacker, Utility.RandomMinMax( 15, 25 ), 100, 0, 0, 0, 0 );
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/Disrobe.cs

@@ -0,0 +1,49 @@
+using System;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// This attack allows you to disrobe your foe.
+	/// </summary>
+	public class Disrobe : WeaponAbility
+	{
+		public Disrobe()
+		{
+		}
+
+		public override int BaseMana{ get{ return 20; } } // Not Sure what amount of mana a creature uses.
+
+		public static readonly TimeSpan BlockEquipDuration = TimeSpan.FromSeconds( 5.0 );
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if ( !Validate( attacker ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+			Item toDisrobe = defender.FindItemOnLayer(Layer.InnerTorso);			
+
+			if ( toDisrobe == null || !toDisrobe.Movable )
+				toDisrobe = defender.FindItemOnLayer( Layer.OuterTorso );
+
+			Container pack = defender.Backpack;
+
+			if ( pack == null || toDisrobe == null || !toDisrobe.Movable )
+			{
+				attacker.SendLocalizedMessage(1004001); // You cannot disarm your opponent.
+			}
+			else if ( CheckMana( attacker, true ) )
+			{
+				//attacker.SendLocalizedMessage( 1060092 ); // You disarm their weapon!
+				defender.SendLocalizedMessage(1062002); // You can no longer wear your ~1_ARMOR~
+
+				defender.PlaySound( 0x3B9 );
+				//defender.FixedParticles( 0x37BE, 232, 25, 9948, EffectLayer.InnerTorso );
+
+				pack.DropItem( toDisrobe );
+
+				BaseWeapon.BlockEquip( defender, BlockEquipDuration );
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/DoubleShot.cs

@@ -0,0 +1,69 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// Send two arrows flying at your opponent if you're mounted. Requires Bushido or Ninjitsu skill.
+	/// </summary>
+	public class DoubleShot : WeaponAbility
+	{
+		public DoubleShot()
+		{
+		}
+
+		public override int BaseMana { get { return 30; } }
+
+		public override bool CheckSkills( Mobile from )
+		{
+			if( GetSkill( from, SkillName.Ninjitsu ) < 50.0  && GetSkill( from, SkillName.Bushido ) < 50.0 )
+			{
+				from.SendLocalizedMessage( 1063347, "50" ); // You need ~1_SKILL_REQUIREMENT~ Bushido or Ninjitsu skill to perform that attack!
+				return false;
+			}
+
+			return base.CheckSkills( from );
+		}
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			Use( attacker, defender );
+		}
+
+		public override void OnMiss( Mobile attacker, Mobile defender )
+		{
+			Use( attacker, defender );
+		}
+
+		public override bool Validate( Mobile from )
+		{
+			if( base.Validate( from ) )
+			{
+				if( from.Mounted )
+					return true;
+				else
+				{
+					from.SendLocalizedMessage( 1070770 ); // You can only execute this attack while mounted!
+					ClearCurrentAbility( from );
+				}
+			}
+
+			return false;
+		}
+
+		public void Use( Mobile attacker, Mobile defender )
+		{
+			if( !Validate( attacker ) || !CheckMana( attacker, true ) || attacker.Weapon == null )	//sanity
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1063348 ); // You launch two shots at once!
+			defender.SendLocalizedMessage( 1063349 ); // You're attacked with a barrage of shots!
+
+			defender.FixedParticles( 0x37B9, 1, 19, 0x251D, EffectLayer.Waist );
+
+			attacker.Weapon.OnSwing( attacker, defender );
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/DoubleStrike.cs

@@ -0,0 +1,57 @@
+using System;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// The highly skilled warrior can use this special attack to make two quick swings in succession.
+	/// Landing both blows would be devastating! 
+	/// </summary>
+	public class DoubleStrike : WeaponAbility
+	{
+		public DoubleStrike()
+		{
+		}
+
+		public override int BaseMana{ get{ return 30; } }
+		public override double DamageScalar{ get{ return 0.9; } }
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if ( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1060084 ); // You attack with lightning speed!
+			defender.SendLocalizedMessage( 1060085 ); // Your attacker strikes with lightning speed!
+
+			defender.PlaySound( 0x3BB );
+			defender.FixedEffect( 0x37B9, 244, 25 );
+
+			// Swing again:
+
+			// If no combatant, wrong map, one of us is a ghost, or cannot see, or deleted, then stop combat
+			if ( defender == null || defender.Deleted || attacker.Deleted || defender.Map != attacker.Map || !defender.Alive || !attacker.Alive || !attacker.CanSee( defender ) )
+			{
+				attacker.Combatant = null;
+				return;
+			}
+
+			IWeapon weapon = attacker.Weapon;
+
+			if ( weapon == null )
+				return;
+
+			if ( !attacker.InRange( defender, weapon.MaxRange ) )
+				return;
+
+			if ( attacker.InLOS( defender ) )
+			{
+				BaseWeapon.InDoubleStrike = true;
+				attacker.RevealingAction();
+				attacker.NextCombatTime = Core.TickCount + (int)weapon.OnSwing(attacker, defender).TotalMilliseconds;
+				BaseWeapon.InDoubleStrike = false;
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/DualWield.cs

@@ -0,0 +1,78 @@
+
+using System;
+using Server;
+using System.Collections;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// Attack faster as you swing with both weapons.
+	/// </summary>
+	public class DualWield : WeaponAbility
+	{
+		private static Hashtable m_Registry = new Hashtable();
+		public static Hashtable Registry { get { return m_Registry; } }
+
+		public DualWield()
+		{
+		}
+
+		public override int BaseMana { get { return 30; } }
+
+		public override bool CheckSkills( Mobile from )
+		{
+			if( GetSkill( from, SkillName.Ninjitsu ) < 50.0 )
+			{
+				from.SendLocalizedMessage( 1063352, "50" ); // You need ~1_SKILL_REQUIREMENT~ Ninjitsu skill to perform that attack!
+				return false;
+			}
+
+			return base.CheckSkills( from );
+		}
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			if( Registry.Contains( attacker ) )
+			{
+				DualWieldTimer existingtimer = (DualWieldTimer)Registry[attacker];
+				existingtimer.Stop();
+				Registry.Remove( attacker );
+			}
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1063362 ); // You dually wield for increased speed!
+
+			attacker.FixedParticles( 0x3779, 1, 15, 0x7F6, 0x3E8, 3, EffectLayer.LeftHand );
+
+			Timer t = new DualWieldTimer( attacker, (int)(20.0 + 3.0 * (attacker.Skills[SkillName.Ninjitsu].Value - 50.0) / 7.0) );	//20-50 % increase
+
+			t.Start();
+			Registry.Add( attacker, t );
+		}
+
+		public class DualWieldTimer : Timer
+		{
+			private Mobile m_Owner;
+			private int m_BonusSwingSpeed;
+
+			public int BonusSwingSpeed { get { return m_BonusSwingSpeed; } }
+
+			public DualWieldTimer( Mobile owner, int bonusSwingSpeed )
+				: base( TimeSpan.FromSeconds( 6.0 ) )
+			{
+				m_Owner = owner;
+				m_BonusSwingSpeed = bonusSwingSpeed;
+				Priority = TimerPriority.FiftyMS;
+			}
+
+			protected override void OnTick()
+			{
+				Registry.Remove( m_Owner );
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/Feint.cs

@@ -0,0 +1,79 @@
+
+using System;
+using System.Collections;
+using Server.Items;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// Gain a defensive advantage over your primary opponent for a short time.
+	/// </summary>
+	public class Feint : WeaponAbility
+	{
+		private static Hashtable m_Registry = new Hashtable();
+		public static Hashtable Registry { get { return m_Registry; } }
+
+		public Feint()
+		{
+		}
+
+		public override int BaseMana { get { return 30; } }
+
+		public override bool CheckSkills( Mobile from )
+		{
+			if( GetSkill( from, SkillName.Ninjitsu ) < 50.0  && GetSkill( from, SkillName.Bushido ) < 50.0 )
+			{
+				from.SendLocalizedMessage( 1063347, "50" ); // You need ~1_SKILL_REQUIREMENT~ Bushido or Ninjitsu skill to perform that attack!
+				return false;
+			}
+
+			return base.CheckSkills( from );
+		}
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			if( Registry.Contains( defender ) )
+			{
+				FeintTimer existingtimer = (FeintTimer)Registry[defender];
+				existingtimer.Stop();
+				Registry.Remove( defender );
+			}
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1063360 ); // You baffle your target with a feint!
+			defender.SendLocalizedMessage( 1063361 ); // You were deceived by an attacker's feint!
+
+			attacker.FixedParticles( 0x3728, 1, 13, 0x7F3, 0x962, 0, EffectLayer.Waist );
+
+			Timer t = new FeintTimer( defender, (int)(20.0 + 3.0 * (Math.Max( attacker.Skills[SkillName.Ninjitsu].Value, attacker.Skills[SkillName.Bushido].Value ) - 50.0) / 7.0) );	//20-50 % decrease
+
+			t.Start();
+			Registry.Add( defender, t );
+		}
+
+		public class FeintTimer : Timer
+		{
+			private Mobile m_Defender;
+			private int m_SwingSpeedReduction;
+
+			public int SwingSpeedReduction { get { return m_SwingSpeedReduction; } }
+
+			public FeintTimer( Mobile defender, int swingSpeedReduction )
+				: base( TimeSpan.FromSeconds( 6.0 ) )
+			{
+				m_Defender = defender;
+				m_SwingSpeedReduction = swingSpeedReduction;
+				Priority = TimerPriority.FiftyMS;
+			}
+
+			protected override void OnTick()
+			{
+				Registry.Remove( m_Defender );
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/FrenziedWhirlwind.cs

@@ -0,0 +1,168 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Spells;
+using Server.Engines.PartySystem;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// A quick attack to all enemies in range of your weapon that causes damage over time. Requires Bushido or Ninjitsu skill.
+	/// </summary>
+	public class FrenziedWhirlwind : WeaponAbility
+	{
+		public FrenziedWhirlwind()
+		{
+		}
+
+		public override bool CheckSkills( Mobile from )
+		{
+			if( GetSkill( from, SkillName.Ninjitsu ) < 50.0  && GetSkill( from, SkillName.Bushido ) < 50.0 )
+			{
+				from.SendLocalizedMessage( 1063347, "50" ); // You need ~1_SKILL_REQUIREMENT~ Bushido or Ninjitsu skill to perform that attack!
+				return false;
+			}
+
+			return base.CheckSkills( from );
+		}
+
+		public override int BaseMana { get { return 30; } }
+
+		private static Hashtable m_Registry = new Hashtable();
+		public static Hashtable Registry { get { return m_Registry; } }
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if( !Validate( attacker ) )	//Mana check after check that there are targets
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			Map map = attacker.Map;
+
+			if( map == null )
+				return;
+
+			BaseWeapon weapon = attacker.Weapon as BaseWeapon;
+
+			if( weapon == null )
+				return;
+
+			ArrayList list = new ArrayList();
+
+			foreach( Mobile m in attacker.GetMobilesInRange( 1 ) )
+				list.Add( m );
+
+			ArrayList targets = new ArrayList();
+
+			for( int i = 0; i < list.Count; ++i )
+			{
+				Mobile m = (Mobile)list[i];
+
+				if( m != defender && m != attacker && SpellHelper.ValidIndirectTarget( attacker, m ) )
+				{
+					if( m == null || m.Deleted || m.Map != attacker.Map || !m.Alive || !attacker.CanSee( m ) || !attacker.CanBeHarmful( m ) )
+						continue;
+
+					if( !attacker.InRange( m, weapon.MaxRange ) )
+						continue;
+
+					if( attacker.InLOS( m ) )
+						targets.Add( m );
+				}
+			}
+
+			if( targets.Count > 0 )
+			{
+				if( !CheckMana( attacker, true ) )
+					return;
+
+				attacker.FixedEffect( 0x3728, 10, 15 );
+				attacker.PlaySound( 0x2A1 );
+
+				// 5-15 damage
+				int amount = (int)(10.0 * ((Math.Max( attacker.Skills[SkillName.Bushido].Value, attacker.Skills[SkillName.Ninjitsu].Value ) - 50.0) / 70.0 + 5));
+
+				for( int i = 0; i < targets.Count; ++i )
+				{
+					Mobile m = (Mobile)targets[i];
+					attacker.DoHarmful( m, true );
+
+					Timer t = Registry[m] as Timer;
+
+					if( t != null )
+					{
+						t.Stop();
+						Registry.Remove( m );
+					}
+
+					t = new InternalTimer( attacker, m, amount );
+					t.Start();
+					Registry.Add( m, t );
+				}
+
+				Timer.DelayCall( TimeSpan.FromSeconds( 2.0 ), new TimerStateCallback( RepeatEffect ), attacker );
+			}
+		}
+
+		private void RepeatEffect( object state )
+		{
+			Mobile attacker = (Mobile)state;
+
+			attacker.FixedEffect( 0x3728, 10, 15 );
+			attacker.PlaySound( 0x2A1 );
+		}
+
+		private class InternalTimer : Timer
+		{
+			private Mobile m_Attacker;
+			private Mobile m_Defender;
+			private double m_DamageRemaining;
+			private double m_DamageToDo;
+
+			private readonly double DamagePerTick;
+
+			public InternalTimer( Mobile attacker, Mobile defender, int totalDamage )
+				: base( TimeSpan.Zero, TimeSpan.FromSeconds( 0.25 ), 12 )	// 3 seconds at .25 seconds apart = 12.  Confirm delay inbetween of .25 each.
+			{
+				m_Attacker = attacker;
+				m_Defender = defender;
+
+				m_DamageRemaining = (double)totalDamage;
+				DamagePerTick = (double)totalDamage / 12 + 0.01;
+
+				Priority = TimerPriority.TwentyFiveMS;
+			}
+
+			protected override void OnTick()
+			{
+				if( !m_Defender.Alive || m_DamageRemaining <= 0 )
+				{
+					Stop();
+					Server.Items.FrenziedWhirlwind.Registry.Remove( m_Defender );
+					return;
+				}
+
+				m_DamageRemaining -= DamagePerTick;
+				m_DamageToDo += DamagePerTick;
+
+				if( m_DamageRemaining <= 0 && m_DamageToDo < 1 )
+					m_DamageToDo = 1.0; //Confirm this 'round up' at the end
+
+				int damage = (int)m_DamageToDo;
+
+				if( damage > 0 )
+				{
+					m_Defender.Damage( damage, m_Attacker );
+					m_DamageToDo -= damage;
+				}
+
+				if( !m_Defender.Alive || m_DamageRemaining <= 0 )
+				{
+					Stop();
+					Server.Items.FrenziedWhirlwind.Registry.Remove( m_Defender );
+				}
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/InfectiousStrike.cs

@@ -0,0 +1,82 @@
+using System;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// This special move represents a significant change to the use of poisons in Age of Shadows.
+	/// Now, only certain weapon types — those that have Infectious Strike as an available special move — will be able to be poisoned.
+	/// Targets will no longer be poisoned at random when hit by poisoned weapons.
+	/// Instead, the wielder must use this ability to deliver the venom.
+	/// While no skill in Poisoning is directly required to use this ability, being knowledgeable in the application and use of toxins
+	/// will allow a character to use Infectious Strike at reduced mana cost and with a chance to inflict more deadly poison on his victim.
+	/// With this change, weapons will no longer be corroded by poison.
+	/// Level 5 poison will be possible when using this special move.
+	/// </summary>
+	public class InfectiousStrike : WeaponAbility
+	{
+		public InfectiousStrike()
+		{
+		}
+
+		public override int BaseMana{ get{ return 15; } }
+
+		public override bool RequiresTactics( Mobile from )
+		{
+			return false;
+		}
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if ( !Validate( attacker ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			BaseWeapon weapon = attacker.Weapon as BaseWeapon;
+
+			if ( weapon == null )
+				return;
+
+			Poison p = weapon.Poison;
+
+			if ( p == null || weapon.PoisonCharges <= 0 )
+			{
+				attacker.SendLocalizedMessage( 1061141 ); // Your weapon must have a dose of poison to perform an infectious strike!
+				return;
+			}
+
+			if ( !CheckMana( attacker, true ) )
+				return;
+
+			--weapon.PoisonCharges;
+
+			// Infectious strike special move now uses poisoning skill to help determine potency 
+			int maxLevel = attacker.Skills[SkillName.Poisoning].Fixed / 200;
+			if ( maxLevel < 0 ) maxLevel = 0;
+			if ( p.Level > maxLevel ) p = Poison.GetPoison( maxLevel );
+
+			if ( (attacker.Skills[SkillName.Poisoning].Value / 100.0) > Utility.RandomDouble() )
+			{
+				int level = p.Level + 1;
+				Poison newPoison = Poison.GetPoison( level );
+
+				if ( newPoison != null )
+				{
+					p = newPoison;
+
+					attacker.SendLocalizedMessage( 1060080 ); // Your precise strike has increased the level of the poison by 1
+					defender.SendLocalizedMessage( 1060081 ); // The poison seems extra effective!
+				}
+			}
+
+			defender.PlaySound( 0xDD );
+			defender.FixedParticles( 0x3728, 244, 25, 9941, 1266, 0, EffectLayer.Waist );
+
+			if ( defender.ApplyPoison( attacker, p ) != ApplyPoisonResult.Immune )
+			{
+				attacker.SendLocalizedMessage( 1008096, true, defender.Name ); // You have poisoned your target : 
+				defender.SendLocalizedMessage( 1008097, false, attacker.Name ); //  : poisoned you!
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/MortalStrike.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// The assassin's friend.
+	/// A successful Mortal Strike will render its victim unable to heal any damage for several seconds. 
+	/// Use a gruesome follow-up to finish off your foe.
+	/// </summary>
+	public class MortalStrike : WeaponAbility
+	{
+		public MortalStrike()
+		{
+		}
+
+		public override int BaseMana{ get{ return 30; } }
+
+		public static readonly TimeSpan PlayerDuration = TimeSpan.FromSeconds( 6.0 );
+		public static readonly TimeSpan NPCDuration = TimeSpan.FromSeconds( 12.0 );
+
+		public override void OnHit(Mobile attacker, Mobile defender, int damage)
+		{
+			if( !Validate( attacker ) || !CheckMana( attacker, true ) )
+			{
+				return;
+			}
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1060086 ); // You deliver a mortal wound!
+			defender.SendLocalizedMessage( 1060087 ); // You have been mortally wounded!
+
+			defender.PlaySound( 0x1E1 );
+			defender.FixedParticles( 0x37B9, 244, 25, 9944, 31, 0, EffectLayer.Waist );
+
+			// Do not reset timer if one is already in place.
+			if ( !IsWounded( defender ) )
+				BeginWound( defender, defender.Player ? PlayerDuration : NPCDuration );
+		}
+
+		private static Hashtable m_Table = new Hashtable();
+
+		public static bool IsWounded( Mobile m )
+		{
+			return m_Table.Contains( m );
+		}
+
+		public static void BeginWound( Mobile m, TimeSpan duration )
+		{
+			Timer t = (Timer)m_Table[m];
+
+			if ( t != null )
+				t.Stop();
+
+			t = new InternalTimer( m, duration );
+			m_Table[m] = t;
+
+			t.Start();
+
+			m.YellowHealthbar = true;
+		}
+
+		public static void EndWound( Mobile m )
+		{
+			if ( !IsWounded( m ) )
+				return;
+
+			Timer t = (Timer)m_Table[m];
+
+			if ( t != null )
+				t.Stop();
+
+			m_Table.Remove( m );
+
+			m.YellowHealthbar = false;
+			m.SendLocalizedMessage( 1060208 ); // You are no longer mortally wounded.
+		}
+
+		private class InternalTimer : Timer
+		{
+			private Mobile m_Mobile;
+
+			public InternalTimer( Mobile m, TimeSpan duration ) : base( duration )
+			{
+				m_Mobile = m;
+				Priority = TimerPriority.TwoFiftyMS;
+			}
+
+			protected override void OnTick()
+			{
+				EndWound( m_Mobile );
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/MovingShot.cs

@@ -0,0 +1,43 @@
+using System;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// Available on some crossbows, this special move allows archers to fire while on the move.
+	/// This shot is somewhat less accurate than normal, but the ability to fire while running is a clear advantage.
+	/// </summary>
+	public class MovingShot : WeaponAbility
+	{
+		public MovingShot()
+		{
+		}
+
+		public override int BaseMana{ get{ return 15; } }
+		public override int AccuracyBonus{ get{ return -25; } }
+
+		public override bool OnBeforeSwing( Mobile attacker, Mobile defender )
+		{
+			return ( Validate( attacker ) && CheckMana( attacker, true ) );
+		}
+		
+		public override void OnMiss( Mobile attacker, Mobile defender )
+		{
+			//Validates in OnSwing for accuracy scalar
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1060089 ); // You fail to execute your special move
+		}
+
+		public override bool ValidatesDuringHit { get { return false; } }
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			//Validates in OnSwing for accuracy scalar
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1060216 ); // Your shot was successful
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/NerveStrike.cs

@@ -0,0 +1,81 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// Does damage and paralyses your opponent for a short time.
+	/// </summary>
+	public class NerveStrike : WeaponAbility
+	{
+		public NerveStrike()
+		{
+		}
+
+		public override int BaseMana { get { return 30; } }
+
+		public override bool CheckSkills( Mobile from )
+		{
+			if( GetSkill( from, SkillName.Bushido ) < 50.0 )
+			{
+				from.SendLocalizedMessage( 1070768, "50" ); // You need ~1_SKILL_REQUIREMENT~ Bushido skill to perform that attack!
+				return false;
+			}
+
+			return base.CheckSkills( from );
+		}
+
+		public override bool OnBeforeSwing( Mobile attacker, Mobile defender )
+		{
+			if( defender.Paralyzed )
+			{
+				attacker.SendLocalizedMessage( 1061923 ); // The target is already frozen.
+				return false;
+			}
+
+			return true;
+		}
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			bool cantpara = Server.Items.ParalyzingBlow.IsImmune(defender);
+
+			if ( cantpara )
+			{
+				attacker.SendLocalizedMessage(1070804); // Your target resists paralysis.
+				defender.SendLocalizedMessage(1070813); // You resist paralysis.
+			}
+			else
+			{
+				attacker.SendLocalizedMessage(1063356); // You cripple your target with a nerve strike!
+				defender.SendLocalizedMessage(1063357); // Your attacker dealt a crippling nerve strike!
+			}
+
+			attacker.PlaySound(0x204);
+			defender.FixedEffect(0x376A, 9, 32);
+			defender.FixedParticles(0x37C4, 1, 8, 0x13AF, 0, 0, EffectLayer.Waist);
+
+			if ( Core.ML )
+			{
+				AOS.Damage( defender, attacker, (int)( 15.0 * ( attacker.Skills[SkillName.Bushido].Value - 50.0 ) / 70.0 + Utility.Random( 10 ) ), true, 100, 0, 0, 0, 0 );	//0-25
+
+				if (!cantpara && ((150.0 / 7.0 + (4.0 * attacker.Skills[SkillName.Bushido].Value) / 7.0) / 100.0) > Utility.RandomDouble())
+				{
+					defender.Paralyze( TimeSpan.FromSeconds( 2.0 ) );
+					Server.Items.ParalyzingBlow.BeginImmunity( defender, Server.Items.ParalyzingBlow.FreezeDelayDuration );				
+				}
+			}
+			else if( !cantpara )
+			{
+				AOS.Damage( defender, attacker, (int)(15.0 * (attacker.Skills[SkillName.Bushido].Value - 50.0) / 70.0 + 10), true, 100, 0, 0, 0, 0 ); //10-25
+				defender.Freeze(TimeSpan.FromSeconds(2.0));
+				Server.Items.ParalyzingBlow.BeginImmunity(defender, Server.Items.ParalyzingBlow.FreezeDelayDuration);
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/ParalyzingBlow.cs

@@ -0,0 +1,136 @@
+using System;
+using System.Collections;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// A successful Paralyzing Blow will leave the target stunned, unable to move, attack, or cast spells, for a few seconds.
+	/// </summary>
+	public class ParalyzingBlow : WeaponAbility
+	{
+		public ParalyzingBlow()
+		{
+		}
+
+		public override int BaseMana{ get{ return 30; } }
+
+		public static readonly TimeSpan PlayerFreezeDuration = TimeSpan.FromSeconds( 3.0 );
+		public static readonly TimeSpan NPCFreezeDuration = TimeSpan.FromSeconds( 6.0 );
+
+		public static readonly TimeSpan FreezeDelayDuration = TimeSpan.FromSeconds( 8.0 );
+
+		// No longer active in pub21:
+		/*public override bool CheckSkills( Mobile from )
+		{
+			if ( !base.CheckSkills( from ) )
+				return false;
+
+			if ( !(from.Weapon is Fists) )
+				return true;
+
+			Skill skill = from.Skills[SkillName.Anatomy];
+
+			if ( skill != null && skill.Base >= 80.0 )
+				return true;
+
+			from.SendLocalizedMessage( 1061811 ); // You lack the required anatomy skill to perform that attack!
+
+			return false;
+		}*/
+
+		public override bool RequiresTactics( Mobile from )
+		{
+			BaseWeapon weapon = from.Weapon as BaseWeapon;
+
+			if ( weapon == null )
+				return true;
+
+			return weapon.Skill != SkillName.Wrestling;
+		}
+
+		public override bool OnBeforeSwing( Mobile attacker, Mobile defender )
+		{
+			if( defender.Paralyzed )
+			{
+				attacker.SendLocalizedMessage( 1061923 ); // The target is already frozen.
+				return false;
+			}
+
+			return true;
+		}
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			if( IsImmune( defender ) )	//Intentionally going after Mana consumption
+			{
+				attacker.SendLocalizedMessage( 1070804 ); // Your target resists paralysis.
+				defender.SendLocalizedMessage( 1070813 ); // You resist paralysis.
+				return;
+			}
+
+			defender.FixedEffect( 0x376A, 9, 32 );
+			defender.PlaySound( 0x204 );
+
+			attacker.SendLocalizedMessage( 1060163 ); // You deliver a paralyzing blow!
+			defender.SendLocalizedMessage( 1060164 ); // The attack has temporarily paralyzed you!
+
+			TimeSpan duration = defender.Player ? PlayerFreezeDuration : NPCFreezeDuration;
+
+			// Treat it as paralyze not as freeze, effect must be removed when damaged.
+			defender.Paralyze( duration );
+
+			BeginImmunity( defender, duration + FreezeDelayDuration );
+		}
+
+		private static Hashtable m_Table = new Hashtable();
+
+		public static bool IsImmune( Mobile m )
+		{
+			return m_Table.Contains( m );
+		}
+
+		public static void BeginImmunity( Mobile m, TimeSpan duration )
+		{
+			Timer t = (Timer)m_Table[m];
+
+			if ( t != null )
+				t.Stop();
+
+			t = new InternalTimer( m, duration );
+			m_Table[m] = t;
+
+			t.Start();
+		}
+
+		public static void EndImmunity( Mobile m )
+		{
+			Timer t = (Timer)m_Table[m];
+
+			if ( t != null )
+				t.Stop();
+
+			m_Table.Remove( m );
+		}
+
+		private class InternalTimer : Timer
+		{
+			private Mobile m_Mobile;
+
+			public InternalTimer( Mobile m, TimeSpan duration ) : base( duration )
+			{
+				m_Mobile = m;
+				Priority = TimerPriority.TwoFiftyMS;
+			}
+
+			protected override void OnTick()
+			{
+				EndImmunity( m_Mobile );
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/RidingSwipe.cs

@@ -0,0 +1,81 @@
+
+using System;
+using Server.Items;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// If you are on foot, dismounts your opponent and damage the ethereal's rider or the
+	/// living mount(which must be healed before ridden again). If you are mounted, damages
+	/// and stuns the mounted opponent.
+	/// </summary>
+	public class RidingSwipe : WeaponAbility
+	{
+		public RidingSwipe()
+		{
+		}
+
+		public override int BaseMana { get { return 30; } }
+
+		public override bool RequiresSE { get { return true; } }
+
+		public override bool CheckSkills( Mobile from )
+		{
+			if( GetSkill( from, SkillName.Bushido ) < 50.0 )
+			{
+				from.SendLocalizedMessage( 1070768, "50" ); // You need ~1_SKILL_REQUIREMENT~ Bushido skill to perform that attack!
+				return false;
+			}
+
+			return base.CheckSkills( from );
+		}
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if( !defender.Mounted )
+			{
+				attacker.SendLocalizedMessage( 1060848 ); // This attack only works on mounted targets
+				ClearCurrentAbility( attacker );
+				return;
+			}
+
+			if( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			if( !attacker.Mounted )
+			{
+				Mobile mount = defender.Mount as Mobile;
+				BaseMount.Dismount( defender );
+
+				if( mount != null )	//Ethy mounts don't take damage
+				{
+					int amount = 10 + (int)(10.0 * (attacker.Skills[SkillName.Bushido].Value - 50.0) / 70.0 + 5);
+										
+					AOS.Damage( mount, null, amount, 100, 0, 0, 0, 0 );	//The mount just takes damage, there's no flagging as if it was attacking the mount directly
+					
+					//TODO: Mount prevention until mount healed
+				}
+			}
+			else
+			{
+				int amount = 10 + (int)(10.0 * (attacker.Skills[SkillName.Bushido].Value - 50.0) / 70.0 + 5);
+				
+				AOS.Damage( defender, attacker, amount, 100, 0, 0, 0, 0 );
+
+				if( Server.Items.ParalyzingBlow.IsImmune( defender ) )	//Does it still do damage?
+				{
+					attacker.SendLocalizedMessage( 1070804 ); // Your target resists paralysis.
+					defender.SendLocalizedMessage( 1070813 ); // You resist paralysis.
+				}
+				else
+				{
+					defender.Paralyze( TimeSpan.FromSeconds( 3.0 ) );
+					Server.Items.ParalyzingBlow.BeginImmunity( defender, Server.Items.ParalyzingBlow.FreezeDelayDuration );
+				}
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/ShadowStrike.cs

@@ -0,0 +1,59 @@
+using System;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// This powerful ability requires secondary skills to activate.
+	/// Successful use of Shadowstrike deals extra damage to the target — and renders the attacker invisible!
+	/// Only those who are adept at the art of stealth will be able to use this ability.
+	/// </summary>
+	public class ShadowStrike : WeaponAbility
+	{
+		public ShadowStrike()
+		{
+		}
+
+		public override int BaseMana{ get{ return 20; } }
+		public override double DamageScalar{ get{ return 1.25; } }
+
+		public override bool RequiresTactics( Mobile from )
+		{
+			return false;
+		}
+
+		public override bool CheckSkills( Mobile from )
+		{
+			if ( !base.CheckSkills( from ) )
+				return false;
+
+			Skill skill = from.Skills[SkillName.Stealth];
+
+			if ( skill != null && skill.Value >= 80.0 )
+				return true;
+
+			from.SendLocalizedMessage( 1060183 ); // You lack the required stealth to perform that attack
+
+			return false;
+		}
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if ( !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1060078 ); // You strike and hide in the shadows!
+			defender.SendLocalizedMessage( 1060079 ); // You are dazed by the attack and your attacker vanishes!
+
+			Effects.SendLocationParticles( EffectItem.Create( attacker.Location, attacker.Map, EffectItem.DefaultDuration ), 0x376A, 8, 12, 9943 );
+			attacker.PlaySound( 0x482 );
+
+			defender.FixedEffect( 0x37BE, 20, 25 );
+
+			attacker.Combatant = null;
+			attacker.Warmode = false;
+			attacker.Hidden = true;
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/TalonStrike.cs

@@ -0,0 +1,106 @@
+
+using System;
+using Server;
+using System.Collections;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// Attack with increased damage with additional damage over time.
+	/// </summary>
+	public class TalonStrike : WeaponAbility
+	{
+		private static Hashtable m_Registry = new Hashtable();
+		public static Hashtable Registry { get { return m_Registry; } }
+
+		public TalonStrike()
+		{
+		}
+
+		public override int BaseMana { get { return 30; } }
+		public override double DamageScalar { get { return 1.2; } }
+
+		public override bool CheckSkills( Mobile from )
+		{
+			if( GetSkill( from, SkillName.Ninjitsu ) < 50.0 )
+			{
+				from.SendLocalizedMessage( 1063352, "50" ); // You need ~1_SKILL_REQUIREMENT~ Ninjitsu skill to perform that attack!
+				return false;
+			}
+
+			return base.CheckSkills( from );
+		}
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if( Registry.Contains( defender ) || !Validate( attacker ) || !CheckMana( attacker, true ) )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			attacker.SendLocalizedMessage( 1063358 ); // You deliver a talon strike!
+			defender.SendLocalizedMessage( 1063359 ); // Your attacker delivers a talon strike!
+
+			defender.FixedParticles( 0x373A, 1, 17, 0x26BC, 0x662, 0, EffectLayer.Waist );
+
+			Timer t = new InternalTimer( defender, (int)(10.0 * (attacker.Skills[SkillName.Ninjitsu].Value - 50.0) / 70.0 + 5), attacker );	//5 - 15 damage
+
+			t.Start();
+
+			Registry.Add( defender, t );
+		}
+
+		private class InternalTimer : Timer
+		{
+			private Mobile m_Defender;
+			private double m_DamageRemaining;
+			private double m_DamageToDo;
+			private Mobile m_Attacker;
+
+			private readonly double DamagePerTick;
+
+			public InternalTimer( Mobile defender, int totalDamage, Mobile attacker )
+				: base( TimeSpan.Zero, TimeSpan.FromSeconds( 0.25 ), 12 )	// 3 seconds at .25 seconds apart = 12.  Confirm delay inbetween of .25 each.
+			{
+				m_Defender = defender;
+				m_DamageRemaining = (double)totalDamage;
+				Priority = TimerPriority.TwentyFiveMS;
+
+				m_Attacker = attacker;
+
+				DamagePerTick = (double)totalDamage / 12+.01;
+			}
+
+			protected override void OnTick()
+			{
+				if( !m_Defender.Alive || m_DamageRemaining <= 0 )
+				{
+					Stop();
+					Server.Items.TalonStrike.Registry.Remove( m_Defender );
+					return;
+				}
+
+				m_DamageRemaining -= DamagePerTick;
+				m_DamageToDo += DamagePerTick;
+
+				if( m_DamageRemaining <= 0 && m_DamageToDo < 1 )
+					m_DamageToDo = 1.0; //Confirm this 'round up' at the end
+
+				int damage = (int)m_DamageToDo;
+
+				if( damage > 0 )
+				{
+					//m_Defender.Damage( damage, m_Attacker, false );
+					m_Defender.Hits -= damage;	//Don't show damage, don't disrupt
+					m_DamageToDo -= damage;
+				}
+
+				if( !m_Defender.Alive || m_DamageRemaining <= 0 )
+				{
+					Stop();
+					Server.Items.TalonStrike.Registry.Remove( m_Defender );
+				}
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/WeaponAbility.cs

@@ -0,0 +1,489 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Network;
+using Server.Spells;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+	public abstract class WeaponAbility
+	{
+		public virtual int BaseMana{ get{ return 0; } }
+
+		public virtual int AccuracyBonus{ get{ return 0; } }
+		public virtual double DamageScalar{ get{ return 1.0; } }
+
+		public virtual bool RequiresSE { get { return false; } }
+
+		public virtual void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+		}
+
+		public virtual void OnMiss( Mobile attacker, Mobile defender )
+		{
+		}
+
+		public virtual bool OnBeforeSwing( Mobile attacker, Mobile defender )
+		{
+			// Here because you must be sure you can use the skill before calling CheckHit if the ability has a HCI bonus for example
+			return true;
+		}
+
+		public virtual bool OnBeforeDamage( Mobile attacker, Mobile defender )
+		{
+			return true;
+		}
+
+		public virtual bool RequiresTactics( Mobile from )
+		{
+			return true;
+		}
+
+		public virtual double GetRequiredSkill( Mobile from )
+		{
+			BaseWeapon weapon = from.Weapon as BaseWeapon;
+
+			if ( weapon != null && weapon.PrimaryAbility == this )
+				return 70.0;
+			else if ( weapon != null && weapon.SecondaryAbility == this )
+				return 90.0;
+
+			return 200.0;
+		}
+
+		public virtual int CalculateMana( Mobile from )
+		{
+			int mana = BaseMana;
+
+			double skillTotal = GetSkill( from, SkillName.Swords ) + GetSkill( from, SkillName.Macing )
+				+ GetSkill( from, SkillName.Fencing ) + GetSkill( from, SkillName.Archery ) + GetSkill( from, SkillName.Parry )
+				+ GetSkill( from, SkillName.Lumberjacking ) + GetSkill( from, SkillName.Stealth )
+				+ GetSkill( from, SkillName.Poisoning ) + GetSkill( from, SkillName.Bushido ) + GetSkill( from, SkillName.Ninjitsu );
+
+			if ( skillTotal >= 300.0 )
+				mana -= 10;
+			else if ( skillTotal >= 200.0 )
+				mana -= 5;
+
+			double scalar = 1.0;
+			if ( !Server.Spells.Necromancy.MindRotSpell.GetMindRotScalar( from, ref scalar ) )
+				scalar = 1.0;
+
+			// Lower Mana Cost = 40%
+			int lmc = Math.Min( AosAttributes.GetValue( from, AosAttribute.LowerManaCost ), 40 );
+
+			scalar -= (double)lmc / 100;
+			mana = (int)(mana * scalar);
+
+			// Using a special move within 3 seconds of the previous special move costs double mana 
+			if ( GetContext( from ) != null )
+				mana *= 2;
+
+			return mana;
+		}
+
+		public virtual bool CheckWeaponSkill( Mobile from )
+		{
+			BaseWeapon weapon = from.Weapon as BaseWeapon;
+
+			if ( weapon == null )
+				return false;
+
+			Skill skill = from.Skills[weapon.Skill];
+			double reqSkill = GetRequiredSkill( from );
+			bool reqTactics = Core.ML && RequiresTactics( from );
+
+			if ( Core.ML && reqTactics && from.Skills[SkillName.Tactics].Base < reqSkill )
+			{
+				from.SendLocalizedMessage( 1079308, reqSkill.ToString() ); // You need ~1_SKILL_REQUIREMENT~ weapon and tactics skill to perform that attack
+				return false;
+			}
+
+			if ( skill != null && skill.Base >= reqSkill )
+				return true;
+
+			/* <UBWS> */
+			if ( weapon.WeaponAttributes.UseBestSkill > 0 && (from.Skills[SkillName.Swords].Base >= reqSkill || from.Skills[SkillName.Macing].Base >= reqSkill || from.Skills[SkillName.Fencing].Base >= reqSkill) )
+				return true;
+			/* </UBWS> */
+
+			if ( reqTactics )
+			{
+				from.SendLocalizedMessage( 1079308, reqSkill.ToString() ); // You need ~1_SKILL_REQUIREMENT~ weapon and tactics skill to perform that attack
+			}
+			else
+			{
+				from.SendLocalizedMessage( 1060182, reqSkill.ToString() ); // You need ~1_SKILL_REQUIREMENT~ weapon skill to perform that attack
+			}
+
+			return false;
+		}
+
+		public virtual bool CheckSkills( Mobile from )
+		{
+			return CheckWeaponSkill( from );
+		}
+
+		public virtual double GetSkill( Mobile from, SkillName skillName )
+		{
+			Skill skill = from.Skills[skillName];
+
+			if ( skill == null )
+				return 0.0;
+
+			return skill.Value;
+		}
+
+		public virtual bool CheckMana( Mobile from, bool consume )
+		{
+			int mana = CalculateMana( from );
+
+			if ( from.Mana < mana )
+			{
+				if( ( from is BaseCreature ) && ( from as BaseCreature ).HasManaOveride )
+				{
+					return true;
+				}
+
+				from.SendLocalizedMessage( 1060181, mana.ToString() ); // You need ~1_MANA_REQUIREMENT~ mana to perform that attack
+				return false;
+			}
+
+			if ( consume )
+			{
+				if ( GetContext( from ) == null )
+				{
+					Timer timer = new WeaponAbilityTimer( from );
+					timer.Start();
+
+					AddContext( from, new WeaponAbilityContext( timer ) );
+				}
+
+				from.Mana -= mana;
+			}
+
+			return true;
+		}
+
+		public virtual bool Validate( Mobile from )
+		{
+			if ( !from.Player )
+				return true;
+
+			NetState state = from.NetState;
+
+			if ( state == null )
+				return false;
+
+			if( RequiresSE && !state.SupportsExpansion( Expansion.SE ) )
+			{
+				from.SendLocalizedMessage( 1063456 ); // You must upgrade to Samurai Empire in order to use that ability.
+				return false;
+			}
+			
+			if ( Spells.Bushido.HonorableExecution.IsUnderPenalty( from ) || Spells.Ninjitsu.AnimalForm.UnderTransformation( from ) )
+			{
+				from.SendLocalizedMessage( 1063024 ); // You cannot perform this special move right now.
+				return false;
+			}
+
+			if ( Core.ML && from.Spell != null )
+			{
+				from.SendLocalizedMessage( 1063024 ); // You cannot perform this special move right now.
+				return false;
+			}
+
+			#region Dueling
+			string option = null;
+
+			if ( this is ArmorIgnore )
+				option = "Armor Ignore";
+			else if ( this is BleedAttack )
+				option = "Bleed Attack";
+			else if ( this is ConcussionBlow )
+				option = "Concussion Blow";
+			else if ( this is CrushingBlow )
+				option = "Crushing Blow";
+			else if ( this is Disarm )
+				option = "Disarm";
+			else if ( this is Dismount )
+				option = "Dismount";
+			else if ( this is DoubleStrike )
+				option = "Double Strike";
+			else if ( this is InfectiousStrike )
+				option = "Infectious Strike";
+			else if ( this is MortalStrike )
+				option = "Mortal Strike";
+			else if ( this is MovingShot )
+				option = "Moving Shot";
+			else if ( this is ParalyzingBlow )
+				option = "Paralyzing Blow";
+			else if ( this is ShadowStrike )
+				option = "Shadow Strike";
+			else if ( this is WhirlwindAttack )
+				option = "Whirlwind Attack";
+			else if ( this is RidingSwipe )
+				option = "Riding Swipe";
+			else if ( this is FrenziedWhirlwind )
+				option = "Frenzied Whirlwind";
+			else if ( this is Block )
+				option = "Block";
+			else if ( this is DefenseMastery )
+				option = "Defense Mastery";
+			else if ( this is NerveStrike )
+				option = "Nerve Strike";
+			else if ( this is TalonStrike )
+				option = "Talon Strike";
+			else if ( this is Feint )
+				option = "Feint";
+			else if ( this is DualWield )
+				option = "Dual Wield";
+			else if ( this is DoubleShot )
+				option = "Double Shot";
+			else if ( this is ArmorPierce )
+				option = "Armor Pierce";
+				
+
+			if ( option != null && !Engines.ConPVP.DuelContext.AllowSpecialAbility( from, option, true ) )
+				return false;
+			#endregion
+
+			return CheckSkills( from ) && CheckMana( from, false );
+		}
+
+		private static WeaponAbility[] m_Abilities = new WeaponAbility[31]
+			{
+				null,
+				new ArmorIgnore(),
+				new BleedAttack(),
+				new ConcussionBlow(),
+				new CrushingBlow(),
+				new Disarm(),
+				new Dismount(),
+				new DoubleStrike(),
+				new InfectiousStrike(),
+				new MortalStrike(),
+				new MovingShot(),
+				new ParalyzingBlow(),
+				new ShadowStrike(),
+				new WhirlwindAttack(),
+
+				new RidingSwipe(),
+				new FrenziedWhirlwind(),
+				new Block(),
+				new DefenseMastery(),
+				new NerveStrike(),
+				new TalonStrike(),
+				new Feint(),
+				new DualWield(),
+				new DoubleShot(),
+				new ArmorPierce(),
+				null,
+				null,
+				null,
+				null,
+				null,
+				null,
+				new Disrobe()
+			};
+
+		public static WeaponAbility[] Abilities{ get{ return m_Abilities; } }
+
+		private static Hashtable m_Table = new Hashtable();
+
+		public static Hashtable Table{ get{ return m_Table; } }
+
+		public static readonly WeaponAbility ArmorIgnore		= m_Abilities[ 1];
+		public static readonly WeaponAbility BleedAttack		= m_Abilities[ 2];
+		public static readonly WeaponAbility ConcussionBlow		= m_Abilities[ 3];
+		public static readonly WeaponAbility CrushingBlow		= m_Abilities[ 4];
+		public static readonly WeaponAbility Disarm				= m_Abilities[ 5];
+		public static readonly WeaponAbility Dismount			= m_Abilities[ 6];
+		public static readonly WeaponAbility DoubleStrike		= m_Abilities[ 7];
+		public static readonly WeaponAbility InfectiousStrike	= m_Abilities[ 8];
+		public static readonly WeaponAbility MortalStrike		= m_Abilities[ 9];
+		public static readonly WeaponAbility MovingShot			= m_Abilities[10];
+		public static readonly WeaponAbility ParalyzingBlow		= m_Abilities[11];
+		public static readonly WeaponAbility ShadowStrike		= m_Abilities[12];
+		public static readonly WeaponAbility WhirlwindAttack	= m_Abilities[13];
+
+		public static readonly WeaponAbility RidingSwipe		= m_Abilities[14];
+		public static readonly WeaponAbility FrenziedWhirlwind  = m_Abilities[15];
+		public static readonly WeaponAbility Block				= m_Abilities[16];
+		public static readonly WeaponAbility DefenseMastery		= m_Abilities[17];
+		public static readonly WeaponAbility NerveStrike		= m_Abilities[18];
+		public static readonly WeaponAbility TalonStrike		= m_Abilities[19];
+		public static readonly WeaponAbility Feint				= m_Abilities[20];
+		public static readonly WeaponAbility DualWield			= m_Abilities[21];
+		public static readonly WeaponAbility DoubleShot			= m_Abilities[22];
+		public static readonly WeaponAbility ArmorPierce		= m_Abilities[23];
+
+		public static readonly WeaponAbility Bladeweave			= m_Abilities[24];
+		public static readonly WeaponAbility ForceArrow			= m_Abilities[25];
+		public static readonly WeaponAbility LightningArrow		= m_Abilities[26];
+		public static readonly WeaponAbility PsychicAttack		= m_Abilities[27];
+		public static readonly WeaponAbility SerpentArrow		= m_Abilities[28];
+		public static readonly WeaponAbility ForceOfNature		= m_Abilities[29];
+
+		public static readonly WeaponAbility Disrobe            = m_Abilities[30];
+
+		public static bool IsWeaponAbility( Mobile m, WeaponAbility a )
+		{
+			if ( a == null )
+				return true;
+
+			if ( !m.Player )
+				return true;
+
+			BaseWeapon weapon = m.Weapon as BaseWeapon;
+
+			return ( weapon != null && (weapon.PrimaryAbility == a || weapon.SecondaryAbility == a) );
+		}
+
+		public virtual bool ValidatesDuringHit{ get { return true; } }
+
+		public static WeaponAbility GetCurrentAbility( Mobile m )
+		{
+			if ( !Core.AOS )
+			{
+				ClearCurrentAbility( m );
+				return null;
+			}
+
+			WeaponAbility a = (WeaponAbility)m_Table[m];
+
+			if ( !IsWeaponAbility( m, a ) )
+			{
+				ClearCurrentAbility( m );
+				return null;
+			}
+
+			if ( a != null && a.ValidatesDuringHit && !a.Validate( m ) )
+			{
+				ClearCurrentAbility( m );
+				return null;
+			}
+
+			return a;
+		}
+
+		public static bool SetCurrentAbility( Mobile m, WeaponAbility a )
+		{
+			if ( !Core.AOS )
+			{
+				ClearCurrentAbility( m );
+				return false;
+			}
+
+			if ( !IsWeaponAbility( m, a ) )
+			{
+				ClearCurrentAbility( m );
+				return false;
+			}
+
+			if ( a != null && !a.Validate( m ) )
+			{
+				ClearCurrentAbility( m );
+				return false;
+			}
+
+			if ( a == null )
+			{
+				m_Table.Remove( m );
+			}
+			else
+			{
+				SpecialMove.ClearCurrentMove( m );
+
+				m_Table[m] = a;
+			}
+
+			return true;
+		}
+
+		public static void ClearCurrentAbility( Mobile m )
+		{
+			m_Table.Remove( m );
+
+			if ( Core.AOS && m.NetState != null )
+				m.Send( ClearWeaponAbility.Instance );
+		}
+
+		public static void Initialize()
+		{
+			EventSink.SetAbility += new SetAbilityEventHandler( EventSink_SetAbility );
+		}
+
+		public WeaponAbility()
+		{
+		}
+
+		private static void EventSink_SetAbility( SetAbilityEventArgs e )
+		{
+			int index = e.Index;
+
+			if ( index == 0 )
+				ClearCurrentAbility( e.Mobile );
+			else if ( index >= 1 && index < m_Abilities.Length )
+				SetCurrentAbility( e.Mobile, m_Abilities[index] );
+		}
+
+
+		private static Hashtable m_PlayersTable = new Hashtable();
+
+		private static void AddContext( Mobile m, WeaponAbilityContext context )
+		{
+			m_PlayersTable[m] = context;
+		}
+
+		private static void RemoveContext( Mobile m )
+		{
+			WeaponAbilityContext context = GetContext( m );
+
+			if ( context != null )
+				RemoveContext( m, context );
+		}
+
+		private static void RemoveContext( Mobile m, WeaponAbilityContext context )
+		{
+			m_PlayersTable.Remove( m );
+
+			context.Timer.Stop();
+		}
+
+		private static WeaponAbilityContext GetContext( Mobile m )
+		{
+			return ( m_PlayersTable[m] as WeaponAbilityContext );
+		}
+
+		private class WeaponAbilityTimer : Timer
+		{
+			private Mobile m_Mobile;
+
+			public WeaponAbilityTimer( Mobile from ) : base ( TimeSpan.FromSeconds( 3.0 ) )
+			{
+				m_Mobile = from;
+
+				Priority = TimerPriority.TwentyFiveMS;
+			}
+
+			protected override void OnTick()
+			{
+				RemoveContext( m_Mobile );
+			}
+		}
+
+		private class WeaponAbilityContext
+		{
+			private Timer m_Timer;
+
+			public Timer Timer{ get{ return m_Timer; } }
+
+			public WeaponAbilityContext( Timer timer )
+			{
+				m_Timer = timer;
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Abilities/WhirlwindAttack.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Spells;
+
+namespace Server.Items
+{
+	/// <summary>
+	/// A godsend to a warrior surrounded, the Whirlwind Attack allows the fighter to strike at all nearby targets in one mighty spinning swing.
+	/// </summary>
+	public class WhirlwindAttack : WeaponAbility
+	{
+		public WhirlwindAttack()
+		{
+		}
+
+		public override int BaseMana{ get{ return 15; } }
+
+		public override void OnHit( Mobile attacker, Mobile defender, int damage )
+		{
+			if ( !Validate( attacker )  )
+				return;
+
+			ClearCurrentAbility( attacker );
+
+			Map map = attacker.Map;
+
+			if ( map == null )
+				return;
+
+			BaseWeapon weapon = attacker.Weapon as BaseWeapon;
+
+			if ( weapon == null )
+				return;
+
+			if ( !CheckMana( attacker, true ) )
+				return;
+
+			attacker.FixedEffect( 0x3728, 10, 15 );
+			attacker.PlaySound( 0x2A1 );
+
+			ArrayList list = new ArrayList();
+
+			foreach ( Mobile m in attacker.GetMobilesInRange( 1 ) )
+				list.Add( m );
+
+			ArrayList targets = new ArrayList();
+
+			for ( int i = 0; i < list.Count; ++i )
+			{
+				Mobile m = (Mobile)list[i];
+
+				if ( m != defender && m != attacker && SpellHelper.ValidIndirectTarget( attacker, m ) )
+				{
+					if ( m == null || m.Deleted || m.Map != attacker.Map || !m.Alive || !attacker.CanSee( m ) || !attacker.CanBeHarmful( m ) )
+						continue;
+
+					if ( !attacker.InRange( m, weapon.MaxRange ) )
+						continue;
+
+					if ( attacker.InLOS( m ) )
+						targets.Add( m );
+				}
+			}
+
+			if ( targets.Count > 0 )
+			{
+				double bushido = attacker.Skills.Bushido.Value;
+				double damageBonus = 1.0 + Math.Pow( (targets.Count * bushido) / 60, 2 ) / 100;
+
+				if ( damageBonus > 2.0 )
+					damageBonus = 2.0;
+					
+				attacker.RevealingAction();
+
+				for ( int i = 0; i < targets.Count; ++i )
+				{
+					Mobile m = (Mobile)targets[i];
+
+						attacker.SendLocalizedMessage( 1060161 ); // The whirling attack strikes a target!
+						m.SendLocalizedMessage( 1060162 ); // You are struck by the whirling attack and take damage!
+
+					weapon.OnHit( attacker, m, damageBonus );
+				}
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/AxeOfTheHeavens.cs

@@ -0,0 +1,42 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class AxeOfTheHeavens : DoubleAxe
+	{
+		public override int LabelNumber{ get{ return 1061106; } } // Axe of the Heavens
+		public override int ArtifactRarity{ get{ return 11; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public AxeOfTheHeavens()
+		{
+			Hue = 0x4D5;
+			WeaponAttributes.HitLightning = 50;
+			Attributes.AttackChance = 15;
+			Attributes.DefendChance = 15;
+			Attributes.WeaponDamage = 50;
+		}
+
+		public AxeOfTheHeavens( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/BladeOfInsanity.cs

@@ -0,0 +1,45 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class BladeOfInsanity : Katana
+	{
+		public override int LabelNumber{ get{ return 1061088; } } // Blade of Insanity
+		public override int ArtifactRarity{ get{ return 11; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public BladeOfInsanity()
+		{
+			Hue = 0x76D;
+			WeaponAttributes.HitLeechStam = 100;
+			Attributes.RegenStam = 2;
+			Attributes.WeaponSpeed = 30;
+			Attributes.WeaponDamage = 50;
+		}
+
+		public BladeOfInsanity( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			if ( Hue == 0x44F )
+				Hue = 0x76D;
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/BladeOfTheRighteous.cs

@@ -0,0 +1,47 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class BladeOfTheRighteous : Longsword
+	{
+		public override int LabelNumber{ get{ return 1061107; } } // Blade of the Righteous
+		public override int ArtifactRarity{ get{ return 10; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public BladeOfTheRighteous()
+		{
+			Hue = 0x47E;
+			//Slayer = SlayerName.DaemonDismissal;
+			Slayer = SlayerName.Exorcism;
+			WeaponAttributes.HitLeechHits = 50;
+			WeaponAttributes.UseBestSkill = 1;
+			Attributes.BonusHits = 10;
+			Attributes.WeaponDamage = 50;
+		}
+
+		public BladeOfTheRighteous( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			if ( Slayer == SlayerName.None )
+				Slayer = SlayerName.Exorcism;
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/BoneCrusher.cs

@@ -0,0 +1,48 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class BoneCrusher : WarMace
+	{
+		public override int LabelNumber{ get{ return 1061596; } } // Bone Crusher
+		public override int ArtifactRarity{ get{ return 11; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public BoneCrusher()
+		{
+			ItemID = 0x1406;
+			Hue = 0x60C;
+			WeaponAttributes.HitLowerDefend = 50;
+			Attributes.BonusStr = 10;
+			Attributes.WeaponDamage = 75;
+		}
+
+		public BoneCrusher( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			if ( Hue == 0x604 )
+				Hue = 0x60C;
+
+			if ( ItemID == 0x1407 )
+				ItemID = 0x1406;
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/BreathOfTheDead.cs

@@ -0,0 +1,42 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class BreathOfTheDead : BoneHarvester
+	{
+		public override int LabelNumber{ get{ return 1061109; } } // Breath of the Dead
+		public override int ArtifactRarity{ get{ return 11; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public BreathOfTheDead()
+		{
+			Hue = 0x455;
+			WeaponAttributes.HitLeechHits = 100;
+			WeaponAttributes.HitHarm = 25;
+			Attributes.SpellDamage = 5;
+			Attributes.WeaponDamage = 50;
+		}
+
+		public BreathOfTheDead( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/Frostbringer.cs

@@ -0,0 +1,47 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class Frostbringer : Bow
+	{
+		public override int LabelNumber{ get{ return 1061111; } } // Frostbringer
+		public override int ArtifactRarity{ get{ return 11; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public Frostbringer()
+		{
+			Hue = 0x4F2;
+			WeaponAttributes.HitDispel = 50;
+			Attributes.RegenStam = 10;
+			Attributes.WeaponDamage = 50;
+		}
+
+		public override void GetDamageTypes( Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct )
+		{
+			phys = fire = pois = nrgy = chaos = direct = 0;
+			cold = 100;
+		}
+
+		public Frostbringer( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/LegacyOfTheDreadLord.cs

@@ -0,0 +1,48 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class LegacyOfTheDreadLord : Bardiche
+	{
+		public override int LabelNumber{ get{ return 1060860; } } // Legacy of the Dread Lord
+		public override int ArtifactRarity{ get{ return 10; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public LegacyOfTheDreadLord()
+		{
+			Hue = 0x676;
+			Attributes.SpellChanneling = 1;
+			Attributes.CastRecovery = 3;
+			Attributes.WeaponSpeed = 30;
+			Attributes.WeaponDamage = 50;
+		}
+
+		public LegacyOfTheDreadLord( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			if ( Attributes.CastSpeed == 3 )
+				Attributes.CastRecovery = 3;
+
+			if ( Hue == 0x4B9 )
+				Hue = 0x676;
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/SerpentsFang.cs

@@ -0,0 +1,53 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class SerpentsFang : Kryss
+	{
+		public override int LabelNumber{ get{ return 1061601; } } // Serpent's Fang
+		public override int ArtifactRarity{ get{ return 11; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public SerpentsFang()
+		{
+			ItemID = 0x1400;
+			Hue = 0x488;
+			WeaponAttributes.HitPoisonArea = 100;
+			WeaponAttributes.ResistPoisonBonus = 20;
+			Attributes.AttackChance = 15;
+			Attributes.WeaponDamage = 50;
+		}
+
+		public override void GetDamageTypes( Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct )
+		{
+			fire = cold = nrgy = chaos = direct = 0;
+			phys = 25;
+			pois = 75;
+		}
+
+		public SerpentsFang( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			if ( ItemID == 0x1401 )
+				ItemID = 0x1400;
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/StaffOfTheMagi.cs

@@ -0,0 +1,54 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class StaffOfTheMagi : BlackStaff
+	{
+		public override int LabelNumber{ get{ return 1061600; } } // Staff of the Magi
+		public override int ArtifactRarity{ get{ return 11; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public StaffOfTheMagi()
+		{
+			Hue = 0x481;
+			WeaponAttributes.MageWeapon = 30;
+			Attributes.SpellChanneling = 1;
+			Attributes.CastSpeed = 1;
+			Attributes.WeaponDamage = 50;
+		}
+
+		public override void GetDamageTypes( Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct )
+		{
+			phys = fire = cold = pois = chaos = direct = 0;
+			nrgy = 100;
+		}
+
+		public StaffOfTheMagi( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			if ( WeaponAttributes.MageWeapon == 0 )
+				WeaponAttributes.MageWeapon = 30;
+
+			if ( ItemID == 0xDF1 )
+				ItemID = 0xDF0;
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/TheBeserkersMaul.cs

@@ -0,0 +1,40 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class TheBeserkersMaul : Maul
+	{
+		public override int LabelNumber{ get{ return 1061108; } } // The Berserker's Maul
+		public override int ArtifactRarity{ get{ return 11; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public TheBeserkersMaul()
+		{
+			Hue = 0x21;
+			Attributes.WeaponSpeed = 75;
+			Attributes.WeaponDamage = 50;
+		}
+
+		public TheBeserkersMaul( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/TheDragonSlayer.cs

@@ -0,0 +1,52 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class TheDragonSlayer : Lance
+	{
+		public override int LabelNumber{ get{ return 1061248; } } // The Dragon Slayer
+		public override int ArtifactRarity{ get{ return 11; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public TheDragonSlayer()
+		{
+			Hue = 0x530;
+			Slayer = SlayerName.DragonSlaying;
+			Attributes.Luck = 110;
+			Attributes.WeaponDamage = 50;
+			WeaponAttributes.ResistFireBonus = 20;
+			WeaponAttributes.UseBestSkill = 1;
+		}
+
+		public override void GetDamageTypes( Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct )
+		{
+			phys = fire = cold = pois = chaos = direct = 0;
+			nrgy = 100;
+		}
+
+		public TheDragonSlayer( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			if ( Slayer == SlayerName.None )
+				Slayer = SlayerName.DragonSlaying;
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/TheDryadBow.cs

@@ -0,0 +1,57 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class TheDryadBow : Bow
+	{
+		public override int LabelNumber{ get{ return 1061090; } } // The Dryad Bow
+		public override int ArtifactRarity{ get{ return 11; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public TheDryadBow()
+		{
+			ItemID = 0x13B1;
+			Hue = 0x48F;
+			SkillBonuses.SetValues( 0, m_PossibleBonusSkills[Utility.Random(m_PossibleBonusSkills.Length)], (Utility.Random( 4 ) == 0 ? 10.0 : 5.0) );
+			WeaponAttributes.SelfRepair = 5;
+			Attributes.WeaponSpeed = 50;
+			Attributes.WeaponDamage = 35;
+			WeaponAttributes.ResistPoisonBonus = 15;
+		}
+
+		private static SkillName[] m_PossibleBonusSkills = new SkillName[]
+			{
+				SkillName.Archery,
+				SkillName.Healing,
+				SkillName.MagicResist,
+				SkillName.Peacemaking,
+				SkillName.Chivalry,
+				SkillName.Ninjitsu
+			};
+
+		public TheDryadBow( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 1 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			if ( version < 1 )
+				SkillBonuses.SetValues( 0, m_PossibleBonusSkills[Utility.Random(m_PossibleBonusSkills.Length)], (Utility.Random( 4 ) == 0 ? 10.0 : 5.0) );
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/TheTaskmaster.cs

@@ -0,0 +1,48 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class TheTaskmaster : WarFork
+	{
+		public override int LabelNumber{ get{ return 1061110; } } // The Taskmaster
+		public override int ArtifactRarity{ get{ return 10; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public TheTaskmaster()
+		{
+			Hue = 0x4F8;
+			WeaponAttributes.HitPoisonArea = 100;
+			Attributes.BonusDex = 5;
+			Attributes.AttackChance = 15;
+			Attributes.WeaponDamage = 50;
+		}
+
+		public override void GetDamageTypes( Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct )
+		{
+			phys = fire = cold = nrgy = chaos = direct = 0;
+			pois = 100;
+		}
+
+		public TheTaskmaster( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/TitansHammer.cs

@@ -0,0 +1,42 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class TitansHammer : WarHammer
+	{
+		public override int LabelNumber{ get{ return 1060024; } } // Titan's Hammer
+		public override int ArtifactRarity{ get{ return 10; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public TitansHammer()
+		{
+			Hue = 0x482;
+			WeaponAttributes.HitEnergyArea = 100;
+			Attributes.BonusStr = 15;
+			Attributes.AttackChance = 15;
+			Attributes.WeaponDamage = 50;
+		}
+
+		public TitansHammer( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Items/Weapons/Artifacts/ZyronicClaw.cs

@@ -0,0 +1,51 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class ZyronicClaw : ExecutionersAxe
+	{
+		public override int LabelNumber{ get{ return 1061593; } } // Zyronic Claw
+		public override int ArtifactRarity{ get{ return 10; } }
+
+		public override int InitMinHits{ get{ return 255; } }
+		public override int InitMaxHits{ get{ return 255; } }
+
+		[Constructable]
+		public ZyronicClaw()
+		{
+			Hue = 0x485;
+			Slayer = SlayerName.ElementalBan;
+			WeaponAttributes.HitLeechMana = 50;
+			Attributes.AttackChance = 30;
+			Attributes.WeaponDamage = 50;
+		}
+
+		public override void GetDamageTypes( Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct )
+		{
+			chaos = direct = 0;
+			phys = fire = cold = pois = nrgy = 20;
+		}
+
+		public ZyronicClaw( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			if ( Slayer == SlayerName.None )
+				Slayer = SlayerName.ElementalBan;
+		}
+	}
+}

Scripts/Items/Weapons/Axes/Axe.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0xF49, 0xF4a )]
+	public class Axe : BaseAxe
+	{
+		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 16; } }
+		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; } }
+
+		[Constructable]
+		public Axe() : base( 0xF49 )
+		{
+			Weight = 4.0;
+		}
+
+		public Axe( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Axes/BaseAxe.cs

@@ -0,0 +1,172 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server;
+using Server.Items;
+using Server.Engines.Harvest;
+using Server.ContextMenus;
+using Server.Network;
+
+namespace Server.Items
+{
+	public interface IAxe
+	{
+		bool Axe( Mobile from, BaseAxe axe );
+	}
+
+	public abstract class BaseAxe : BaseMeleeWeapon
+	{
+		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; } }
+
+		private int m_UsesRemaining;
+		private bool m_ShowUsesRemaining;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int UsesRemaining
+		{
+			get { return m_UsesRemaining; }
+			set { m_UsesRemaining = value; InvalidateProperties(); }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public bool ShowUsesRemaining
+		{
+			get { return m_ShowUsesRemaining; }
+			set { m_ShowUsesRemaining = value; InvalidateProperties(); }
+		}
+
+		public virtual int GetUsesScalar()
+		{
+			if ( Quality == WeaponQuality.Exceptional )
+				return 200;
+
+			return 100;
+		}
+
+		public override void UnscaleDurability()
+		{
+			base.UnscaleDurability();
+
+			int scale = GetUsesScalar();
+
+			m_UsesRemaining = ((m_UsesRemaining * 100) + (scale - 1)) / scale;
+			InvalidateProperties();
+		}
+
+		public override void ScaleDurability()
+		{
+			base.ScaleDurability();
+
+			int scale = GetUsesScalar();
+
+			m_UsesRemaining = ((m_UsesRemaining * scale) + 99) / 100;
+			InvalidateProperties();
+		}
+
+		public BaseAxe( int itemID ) : base( itemID )
+		{
+			m_UsesRemaining = 150;
+		}
+
+		public BaseAxe( Serial serial ) : base( serial )
+		{
+		}
+
+		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 ( !this.IsAccessibleTo( from ) )
+			{
+				this.PublicOverheadMessage( MessageType.Regular, 0x3E9, 1061637 ); // You are not allowed to access this.
+				return;
+			}
+			
+			if ( !(this.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 )
+				BaseHarvestTool.AddContextMenuEntries( from, this, list, HarvestSystem );
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 2 ); // version
+
+			writer.Write( (bool) m_ShowUsesRemaining );
+
+			writer.Write( (int) m_UsesRemaining );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 2:
+				{
+					m_ShowUsesRemaining = reader.ReadBool();
+					goto case 1;
+				}
+				case 1:
+				{
+					m_UsesRemaining = reader.ReadInt();
+					goto case 0;
+				}
+				case 0:
+				{
+					if ( m_UsesRemaining < 1 )
+						m_UsesRemaining = 150;
+
+					break;
+				}
+			}
+		}
+
+		public override void OnHit( Mobile attacker, Mobile defender, double damageBonus )
+		{
+			base.OnHit( attacker, defender, damageBonus );
+
+			if (!Core.AOS && (attacker.Player || attacker.Body.IsHuman) && Layer == Layer.TwoHanded && attacker.Skills[SkillName.Anatomy].Value >= 80 && (attacker.Skills[SkillName.Anatomy].Value / 400.0) >= Utility.RandomDouble() && Engines.ConPVP.DuelContext.AllowSpecialAbility(attacker, "Concussion Blow", false))
+			{
+				StatMod mod = defender.GetStatMod( "Concussion" );
+
+				if ( mod == null )
+				{
+					defender.SendMessage( "You receive a concussion blow!" );
+					defender.AddStatMod( new StatMod( StatType.Int, "Concussion", -(defender.RawInt / 2), TimeSpan.FromSeconds( 30.0 ) ) );
+
+					attacker.SendMessage( "You deliver a concussion blow!" );
+					attacker.PlaySound( 0x308 );
+				}
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Axes/BattleAxe.cs

@@ -0,0 +1,52 @@
+using System;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0xF47, 0xF48 )]
+	public class BattleAxe : BaseAxe
+	{
+		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 15; } }
+		public override int AosMaxDamage{ get{ return 17; } }
+		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; } }
+
+		[Constructable]
+		public BattleAxe() : base( 0xF47 )
+		{
+			Weight = 4.0;
+			Layer = Layer.TwoHanded;
+		}
+
+		public BattleAxe( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Axes/DoubleAxe.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0xf4b, 0xf4c )]
+	public class DoubleAxe : BaseAxe
+	{
+		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 17; } }
+		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; } }
+
+		[Constructable]
+		public DoubleAxe() : base( 0xF4B )
+		{
+			Weight = 8.0;
+		}
+
+		public DoubleAxe( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Axes/ExecutionersAxe.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0xf45, 0xf46 )]
+	public class ExecutionersAxe : BaseAxe
+	{
+		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 17; } }
+		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; } }
+
+		[Constructable]
+		public ExecutionersAxe() : base( 0xF45 )
+		{
+			Weight = 8.0;
+		}
+
+		public ExecutionersAxe( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Axes/GuardianAxe.cs

@@ -0,0 +1,35 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class GuardianAxe : OrnateAxe
+	{
+		public override int LabelNumber{ get{ return 1073545; } } // guardian axe
+
+		[Constructable]
+		public GuardianAxe()
+		{
+			Attributes.BonusHits = 4;
+			Attributes.RegenHits = 1;
+		}
+
+		public GuardianAxe( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/Axes/Hatchet.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0xF43, 0xF44 )]
+	public class Hatchet : BaseAxe
+	{
+		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 15; } }
+		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; } }
+
+		[Constructable]
+		public Hatchet() : base( 0xF43 )
+		{
+			Weight = 4.0;
+		}
+
+		public Hatchet( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Axes/HeavyOrnateAxe.cs

@@ -0,0 +1,34 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class HeavyOrnateAxe : OrnateAxe
+	{
+		public override int LabelNumber{ get{ return 1073548; } } // heavy ornate axe
+
+		[Constructable]
+		public HeavyOrnateAxe()
+		{
+			Attributes.WeaponDamage = 8;
+		}
+
+		public HeavyOrnateAxe( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/Axes/LargeBattleAxe.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x13FB, 0x13FA )]
+	public class LargeBattleAxe : BaseAxe
+	{
+		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 16; } }
+		public override int AosMaxDamage{ get{ return 17; } }
+		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; } }
+
+		[Constructable]
+		public LargeBattleAxe() : base( 0x13FB )
+		{
+			Weight = 6.0;
+		}
+
+		public LargeBattleAxe( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Axes/Pickaxe.cs

@@ -0,0 +1,59 @@
+using System;
+using Server.Items;
+using Server.Network;
+using Server.Engines.Harvest;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0xE86, 0xE85 )]
+	public class Pickaxe : BaseAxe, IUsesRemaining
+	{
+		public override HarvestSystem HarvestSystem{ get{ return Mining.System; } }
+
+		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 13; } }
+		public override int AosMaxDamage{ get{ return 15; } }
+		public override int AosSpeed{ get{ return 35; } }
+		public override float MlSpeed{ get{ return 3.00f; } }
+
+		public override int OldStrengthReq{ get{ return 25; } }
+		public override int OldMinDamage{ get{ return 1; } }
+		public override int OldMaxDamage{ get{ return 15; } }
+		public override int OldSpeed{ get{ return 35; } }
+
+		public override int InitMinHits{ get{ return 31; } }
+		public override int InitMaxHits{ get{ return 60; } }
+
+		public override WeaponAnimation DefAnimation{ get{ return WeaponAnimation.Slash1H; } }
+
+		[Constructable]
+		public Pickaxe() : base( 0xE86 )
+		{
+			Weight = 11.0;
+			UsesRemaining = 50;
+			ShowUsesRemaining = true;
+		}
+
+		public Pickaxe( 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();
+			ShowUsesRemaining = true;
+		}
+	}
+}

Scripts/Items/Weapons/Axes/SingingAxe.cs

@@ -0,0 +1,34 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class SingingAxe : OrnateAxe
+	{
+		public override int LabelNumber{ get{ return 1073546; } } // singing axe
+
+		[Constructable]
+		public SingingAxe()
+		{
+			SkillBonuses.SetValues( 0, SkillName.Musicianship, 5 );
+		}
+
+		public SingingAxe( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/Axes/ThunderingAxe.cs

@@ -0,0 +1,34 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class ThunderingAxe : OrnateAxe
+	{
+		public override int LabelNumber{ get{ return 1073547; } } // thundering axe
+
+		[Constructable]
+		public ThunderingAxe()
+		{
+			WeaponAttributes.HitLightning = 10;
+		}
+
+		public ThunderingAxe( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/Axes/TwoHandedAxe.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x1443, 0x1442 )]
+	public class TwoHandedAxe : BaseAxe
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.DoubleStrike; } }
+		public override WeaponAbility SecondaryAbility{ get{ return WeaponAbility.ShadowStrike; } }
+
+		public override int AosStrengthReq{ get{ return 40; } }
+		public override int AosMinDamage{ get{ return 16; } }
+		public override int AosMaxDamage{ get{ return 17; } }
+		public override int AosSpeed{ get{ return 31; } }
+		public override float MlSpeed{ get{ return 3.50f; } }
+
+		public override int OldStrengthReq{ get{ return 35; } }
+		public override int OldMinDamage{ get{ return 5; } }
+		public override int OldMaxDamage{ get{ return 39; } }
+		public override int OldSpeed{ get{ return 30; } }
+
+		public override int InitMinHits{ get{ return 31; } }
+		public override int InitMaxHits{ get{ return 90; } }
+
+		[Constructable]
+		public TwoHandedAxe() : base( 0x1443 )
+		{
+			Weight = 8.0;
+		}
+
+		public TwoHandedAxe( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Axes/WarAxe.cs

@@ -0,0 +1,61 @@
+using System;
+using Server.Items;
+using Server.Network;
+using Server.Engines.Harvest;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x13B0, 0x13AF )]
+	public class WarAxe : BaseAxe
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.ArmorIgnore; } }
+		public override WeaponAbility SecondaryAbility{ get{ return WeaponAbility.BleedAttack; } }
+
+		public override int AosStrengthReq{ get{ return 35; } }
+		public override int AosMinDamage{ get{ return 14; } }
+		public override int AosMaxDamage{ get{ return 15; } }
+		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 9; } }
+		public override int OldMaxDamage{ get{ return 27; } }
+		public override int OldSpeed{ get{ return 40; } }
+
+		public override int DefHitSound{ get{ return 0x233; } }
+		public override int DefMissSound{ get{ return 0x239; } }
+
+		public override int InitMinHits{ get{ return 31; } }
+		public override int InitMaxHits{ get{ return 80; } }
+
+		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 HarvestSystem HarvestSystem{ get{ return null; } }
+
+		[Constructable]
+		public WarAxe() : base( 0x13B0 )
+		{
+			Weight = 8.0;
+		}
+
+		public WarAxe( 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();
+		}
+	}
+}

Scripts/Items/Weapons/BaseMeleeWeapon.cs

@@ -0,0 +1,66 @@
+using System;
+using Server;
+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 );
+
+			AttuneWeaponSpell.TryAbsorb( defender, ref 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/Weapons/Fists.cs

@@ -0,0 +1,312 @@
+using System;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Items
+{
+	public class Fists : BaseMeleeWeapon
+	{
+		public static void Initialize()
+		{
+			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 4; } }
+		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 = WeaponQuality.Regular;
+		}
+
+		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, Mobile defender )
+		{
+			if ( !Core.AOS )
+				CheckPreAOSMoves( attacker, 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();
+
+			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;
+
+			#region Dueling
+			if ( !Engines.ConPVP.DuelContext.AllowSpecialAbility( m, "Disarm", true ) )
+				return;
+			#endregion
+
+			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;
+
+			#region Dueling
+			if ( !Engines.ConPVP.DuelContext.AllowSpecialAbility( m, "Stun", true ) )
+				return;
+			#endregion
+
+			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 Mobile m_Mobile;
+
+			public MoveDelayTimer( Mobile m ) : base( TimeSpan.FromSeconds( 10.0 ) )
+			{
+				m_Mobile = m;
+
+				Priority = TimerPriority.TwoFiftyMS;
+
+				m_Mobile.BeginAction( typeof( Fists ) );
+			}
+
+			protected override void OnTick()
+			{
+				m_Mobile.EndAction( typeof( Fists ) );
+			}
+		}
+
+		private static void StartMoveDelay( Mobile m )
+		{
+			new MoveDelayTimer( m ).Start();
+		}
+	}
+}

Scripts/Items/Weapons/HitLower.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections;
+using Server;
+
+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 Hashtable m_AttackTable = new Hashtable();
+
+		public static bool IsUnderAttackEffect( Mobile m )
+		{
+			return m_AttackTable.Contains( m );
+		}
+
+		public static bool ApplyAttack( Mobile m )
+		{
+			if ( IsUnderAttackEffect( m ) )
+				return false;
+
+			m_AttackTable[m] = new AttackTimer( m );
+			m.SendLocalizedMessage( 1062319 ); // Your attack chance has been reduced!
+			return true;
+		}
+
+		private static void RemoveAttack( Mobile m )
+		{
+			m_AttackTable.Remove( m );
+			m.SendLocalizedMessage( 1062320 ); // Your attack chance has returned to normal.
+		}
+
+		private class AttackTimer : Timer
+		{
+			private Mobile m_Player;
+
+			public AttackTimer( Mobile player ) : base( AttackEffectDuration )
+			{
+				m_Player = player;
+
+				Priority = TimerPriority.TwoFiftyMS;
+
+				Start();
+			}
+
+			protected override void OnTick()
+			{
+				RemoveAttack( m_Player );
+			}
+		}
+
+		private static Hashtable m_DefenseTable = new Hashtable();
+
+		public static bool IsUnderDefenseEffect( Mobile m )
+		{
+			return m_DefenseTable.Contains( m );
+		}
+
+		public static bool ApplyDefense( Mobile m )
+		{
+			if ( IsUnderDefenseEffect( m ) )
+				return false;
+
+			m_DefenseTable[m] = new DefenseTimer( m );
+			m.SendLocalizedMessage( 1062318 ); // Your defense chance has been reduced!
+			return true;
+		}
+
+		private static void RemoveDefense( Mobile m )
+		{
+			m_DefenseTable.Remove( m );
+			m.SendLocalizedMessage( 1062321 ); // Your defense chance has returned to normal.
+		}
+
+		private class DefenseTimer : Timer
+		{
+			private Mobile m_Player;
+
+			public DefenseTimer( Mobile player ) : base( DefenseEffectDuration )
+			{
+				m_Player = player;
+
+				Priority = TimerPriority.TwoFiftyMS;
+
+				Start();
+			}
+
+			protected override void OnTick()
+			{
+				RemoveDefense( m_Player );
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Knives/BaseKnife.cs

@@ -0,0 +1,59 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Targets;
+
+namespace Server.Items
+{
+	public abstract class BaseKnife : BaseMeleeWeapon
+	{
+		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 BaseKnife( int itemID ) : base( itemID )
+		{
+		}
+
+		public BaseKnife( 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 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, Mobile defender, double damageBonus )
+		{
+			base.OnHit( attacker, defender, damageBonus );
+
+			if ( !Core.AOS && Poison != null && PoisonCharges > 0 )
+			{
+				--PoisonCharges;
+
+				if ( Utility.RandomDouble() >= 0.5 ) // 50% chance to poison
+					defender.ApplyPoison( attacker, Poison );
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Knives/ButcherKnife.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x13F6, 0x13F7 )]
+	public class ButcherKnife : BaseKnife
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.InfectiousStrike; } }
+		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 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; } }
+
+		[Constructable]
+		public ButcherKnife() : base( 0x13F6 )
+		{
+			Weight = 1.0;
+		}
+
+		public ButcherKnife( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Knives/Cleaver.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0xEC3, 0xEC2 )]
+	public class Cleaver : BaseKnife
+	{
+		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 11; } }
+		public override int AosMaxDamage{ get{ return 13; } }
+		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; } }
+
+		[Constructable]
+		public Cleaver() : base( 0xEC3 )
+		{
+			Weight = 2.0;
+		}
+
+		public Cleaver( 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();
+
+			if ( Weight == 1.0 )
+				Weight = 2.0;
+		}
+	}
+}

Scripts/Items/Weapons/Knives/Dagger.cs

@@ -0,0 +1,56 @@
+using System;
+using Server.Network;
+using Server.Targeting;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0xF52, 0xF51 )]
+	public class Dagger : BaseKnife
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.InfectiousStrike; } }
+		public override WeaponAbility SecondaryAbility{ get{ return WeaponAbility.ShadowStrike; } }
+
+		public override int AosStrengthReq{ get{ return 10; } }
+		public override int AosMinDamage{ get{ return 10; } }
+		public override int AosMaxDamage{ get{ return 11; } }
+		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; } }
+
+		[Constructable]
+		public Dagger() : base( 0xF52 )
+		{
+			Weight = 1.0;
+		}
+
+		public Dagger( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Knives/SkinningKnife.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0xEC4, 0xEC5 )]
+	public class SkinningKnife : BaseKnife
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.ShadowStrike; } }
+		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 49; } }
+		public override float MlSpeed{ get{ return 2.25f; } }
+
+		public override int OldStrengthReq{ get{ return 5; } }
+		public override int OldMinDamage{ get{ return 1; } }
+		public override int OldMaxDamage{ get{ return 10; } }
+		public override int OldSpeed{ get{ return 40; } }
+
+		public override int InitMinHits{ get{ return 31; } }
+		public override int InitMaxHits{ get{ return 40; } }
+
+		[Constructable]
+		public SkinningKnife() : base( 0xEC4 )
+		{
+			Weight = 1.0;
+		}
+
+		public SkinningKnife( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Knives/ThrowingDagger.cs

@@ -0,0 +1,125 @@
+using System;
+using Server.Targeting;
+using Server.Network;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0xF52, 0xF51 )]
+	public class ThrowingDagger : Item
+	{
+		public override string DefaultName
+		{
+			get { return "a throwing dagger"; }
+		}
+
+		[Constructable]
+		public ThrowingDagger() : base( 0xF52 )
+		{
+			Weight = 1.0;
+			Layer = Layer.OneHanded;
+		}
+
+		public ThrowingDagger( 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 OnDoubleClick( Mobile from )
+		{
+			if ( from.Items.Contains( this ) )
+			{
+				InternalTarget t = new InternalTarget( this );
+				from.Target = t;
+			}
+			else
+			{
+				from.SendMessage( "You must be holding that weapon to use it." );
+			}
+		}
+
+		private class InternalTarget : Target
+		{
+			private ThrowingDagger m_Dagger;
+
+			public InternalTarget( ThrowingDagger dagger ) : base( 10, false, TargetFlags.Harmful )
+			{
+				m_Dagger = dagger;
+			}
+
+			protected override void OnTarget( Mobile from, object targeted )
+			{
+				if ( m_Dagger.Deleted )
+				{
+					return;
+				}
+				else if ( !from.Items.Contains( m_Dagger ) )
+				{
+					from.SendMessage( "You must be holding that weapon to use it." );
+				}
+				else if ( targeted is Mobile )
+				{
+					Mobile m = (Mobile)targeted;
+
+					if ( m != from && from.HarmfulCheck( m ) )
+					{
+						Direction to = from.GetDirectionTo( m );
+
+						from.Direction = to;
+
+						from.Animate( from.Mounted ? 26 : 9, 7, 1, true, false, 0 );
+
+						if ( Utility.RandomDouble() >= (Math.Sqrt( m.Dex / 100.0 ) * 0.8) )
+						{
+							from.MovingEffect( m, 0x1BFE, 7, 1, false, false, 0x481, 0 );
+
+							AOS.Damage( m, from, Utility.Random( 5, from.Str / 10 ), 100, 0, 0, 0, 0 );
+
+							m_Dagger.MoveToWorld( m.Location, m.Map );
+						}
+						else
+						{
+							int x = 0, y = 0;
+
+							switch ( to & Direction.Mask )
+							{
+								case Direction.North: --y; break;
+								case Direction.South: ++y; break;
+								case Direction.West: --x; break;
+								case Direction.East: ++x; break;
+								case Direction.Up: --x; --y; break;
+								case Direction.Down: ++x; ++y; break;
+								case Direction.Left: --x; ++y; break;
+								case Direction.Right: ++x; --y; break;
+							}
+
+							x += Utility.Random( -1, 3 );
+							y += Utility.Random( -1, 3 );
+
+							x += m.X;
+							y += m.Y;
+
+							m_Dagger.MoveToWorld( new Point3D( x, y, m.Z ), m.Map );
+
+							from.MovingEffect( m_Dagger, 0x1BFE, 7, 1, false, false, 0x481, 0 );
+
+							from.SendMessage( "You miss." );
+						}
+					}
+				}
+			}
+		}
+	}
+}

Scripts/Items/Weapons/ML Weapons/Artifacts/BlightGrippedLongbow.cs

@@ -0,0 +1,40 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class BlightGrippedLongbow : ElvenCompositeLongbow
+	{
+		public override int LabelNumber{ get{ return 1072907; } } // Blight Gripped Longbow
+
+		[Constructable]
+		public BlightGrippedLongbow()
+		{
+			Hue = 0x8A4;
+
+			WeaponAttributes.HitPoisonArea = 20;
+			Attributes.RegenStam = 3;
+			Attributes.NightSight = 1;
+			Attributes.WeaponSpeed = 20;
+			Attributes.WeaponDamage = 35;
+		}
+
+		public BlightGrippedLongbow( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/Artifacts/ColdForgedBlade.cs

@@ -0,0 +1,47 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class ColdForgedBlade : ElvenSpellblade
+	{
+		public override int LabelNumber{ get{ return 1072916; } } // Cold Forged Blade
+
+		[Constructable]
+		public ColdForgedBlade()
+		{
+			WeaponAttributes.HitHarm = 40;
+			Attributes.SpellChanneling = 1;
+			Attributes.NightSight = 1;
+			Attributes.WeaponSpeed = 25;
+			Attributes.WeaponDamage = 50;
+
+			Hue = this.GetElementalDamageHue();
+		}
+
+		public override void GetDamageTypes( Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct )
+		{
+			phys = fire = pois = nrgy = chaos = direct = 0;
+			cold = 100;
+		}
+
+		public ColdForgedBlade( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/Artifacts/LuminousRuneBlade.cs

@@ -0,0 +1,47 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class LuminousRuneBlade : RuneBlade
+	{
+		public override int LabelNumber{ get{ return 1072922; } } // Luminous Rune Blade
+
+		[Constructable]
+		public LuminousRuneBlade()
+		{
+			WeaponAttributes.HitLightning = 40;
+			WeaponAttributes.SelfRepair = 5;
+			Attributes.NightSight = 1;
+			Attributes.WeaponSpeed = 25;
+			Attributes.WeaponDamage = 55;
+
+			Hue = this.GetElementalDamageHue();
+		}
+
+		public override void GetDamageTypes( Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct )
+		{
+			phys = fire = cold = pois = chaos = direct = 0;
+			nrgy = 100;
+		}
+
+		public LuminousRuneBlade( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/Artifacts/OverseerSunderedBlade.cs

@@ -0,0 +1,49 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class OverseerSunderedBlade : RadiantScimitar
+	{
+		public override int LabelNumber{ get{ return 1072920; } } // Overseer Sundered Blade
+
+		[Constructable]
+		public OverseerSunderedBlade()
+		{
+			ItemID = 0x2D27;
+			Hue = 0x485;
+
+			Attributes.RegenStam = 2;
+			Attributes.AttackChance = 10;
+			Attributes.WeaponSpeed = 35;
+			Attributes.WeaponDamage = 45;
+
+			Hue = this.GetElementalDamageHue();
+		}
+
+		public override void GetDamageTypes( Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct )
+		{
+			phys = cold = pois = nrgy = chaos = direct = 0;
+			fire = 100;
+		}
+
+		public OverseerSunderedBlade( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/Artifacts/PhantomStaff.cs

@@ -0,0 +1,45 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class PhantomStaff : WildStaff
+	{
+		public override int LabelNumber{ get{ return 1072919; } } // Phantom Staff
+
+		[Constructable]
+		public PhantomStaff()
+		{
+			Hue = 0x1;
+			Attributes.RegenHits = 2;
+			Attributes.NightSight = 1;
+			Attributes.WeaponSpeed = 20;
+			Attributes.WeaponDamage = 60;
+		}
+
+		public override void GetDamageTypes( Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct )
+		{
+			phys = fire = nrgy = chaos = direct = 0;
+			cold = pois = 50;
+		}
+
+		public PhantomStaff( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/Artifacts/RuneCarvingKnife.cs

@@ -0,0 +1,41 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class RuneCarvingKnife : AssassinSpike
+	{
+		public override int LabelNumber{ get{ return 1072915; } } // Rune Carving Knife
+
+		[Constructable]
+		public RuneCarvingKnife()
+		{
+			Hue = 0x48D;
+
+			WeaponAttributes.HitLeechMana = 40;
+			Attributes.RegenStam = 2;
+			Attributes.LowerManaCost = 10;
+			Attributes.WeaponSpeed = 35;
+			Attributes.WeaponDamage = 30;
+		}
+
+		public RuneCarvingKnife( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/Artifacts/ShardTrasher.cs

@@ -0,0 +1,41 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class ShardThrasher : DiamondMace
+	{
+		public override int LabelNumber{ get{ return 1072918; } } // Shard Thrasher
+
+		[Constructable]
+		public ShardThrasher()
+		{
+			Hue = 0x4F2;
+
+			WeaponAttributes.HitPhysicalArea = 30;
+			Attributes.BonusStam = 8;
+			Attributes.AttackChance = 10;
+			Attributes.WeaponSpeed = 35;
+			Attributes.WeaponDamage = 40;
+		}
+
+		public ShardThrasher( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/Artifacts/SilvanisFeywoodBow.cs

@@ -0,0 +1,46 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class SilvanisFeywoodBow : ElvenCompositeLongbow
+	{
+		public override int LabelNumber{ get{ return 1072955; } } // Silvani's Feywood Bow
+
+		[Constructable]
+		public SilvanisFeywoodBow()
+		{
+			Hue = 0x1A;
+
+			Attributes.SpellChanneling = 1;
+			Attributes.AttackChance = 12;
+			Attributes.WeaponSpeed = 30;
+			Attributes.WeaponDamage = 35;
+		}
+
+		public override void GetDamageTypes( Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct )
+		{
+			phys = fire = cold = pois = chaos = direct = 0;
+			nrgy = 100;
+		}
+
+		public SilvanisFeywoodBow( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/Artifacts/TheNightReaper.cs

@@ -0,0 +1,41 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class TheNightReaper : RepeatingCrossbow
+	{
+		public override int LabelNumber{ get{ return 1072912; } } // The Night Reaper
+
+		[Constructable]
+		public TheNightReaper()
+		{
+			ItemID = 0x26CD;
+			Hue = 0x41C;
+
+			Slayer = SlayerName.Exorcism;
+			Attributes.NightSight = 1;
+			Attributes.WeaponSpeed = 25;
+			Attributes.WeaponDamage = 55;
+		}
+
+		public TheNightReaper( 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();
+		}
+	}
+}

Scripts/Items/Weapons/ML Weapons/AssassinSpike.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x2D21, 0x2D2D )]
+	public class AssassinSpike : BaseKnife
+	{
+		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
+
+		[Constructable]
+		public AssassinSpike() : base( 0x2D21 )
+		{
+			Weight = 4.0;
+		}
+
+		public AssassinSpike( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/ButchersWarCleaver.cs

@@ -0,0 +1,40 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class ButchersWarCleaver : WarCleaver
+	{
+		public override int LabelNumber{ get{ return 1073526; } } // butcher's war cleaver
+
+		[Constructable]
+		public ButchersWarCleaver() : base()
+		{
+		}
+
+		public ButchersWarCleaver( Serial serial ) : base( serial )
+		{
+		}
+		
+		public override void AppendChildNameProperties( ObjectPropertyList list )
+		{
+			base.AppendChildNameProperties( list );
+			
+			list.Add( 1072512 ); // Bovine Slayer
+		}
+
+		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/Weapons/ML Weapons/DiamondMace.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x2D24, 0x2D30 )]
+	public class DiamondMace : BaseBashing
+	{
+		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 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 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
+
+		[Constructable]
+		public DiamondMace() : base( 0x2D24 )
+		{
+			Weight = 10.0;
+		}
+
+		public DiamondMace( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/ElvenCompositeLongbow.cs

@@ -0,0 +1,59 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x2D1E, 0x2D2A )]
+	public class ElvenCompositeLongbow : BaseRanged
+	{
+		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 12; } }
+		public override int AosMaxDamage{ get{ return 16; } }
+		public override int AosSpeed{ get{ return 27; } }
+		public override float MlSpeed{ get{ return 4.00f; } }
+
+		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; } }
+
+		[Constructable]
+		public ElvenCompositeLongbow() : base( 0x2D1E )
+		{
+			Weight = 8.0;
+		}
+
+		public ElvenCompositeLongbow( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/ElvenMachete.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x2D35, 0x2D29 )]
+	public class ElvenMachete : BaseSword
+	{
+		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 13; } }
+		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; } }
+
+		[Constructable]
+		public ElvenMachete() : base( 0x2D35 )
+		{
+			Weight = 6.0;
+		}
+
+		public ElvenMachete( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/ElvenSpellblade.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x2D20, 0x2D2C )]
+	public class ElvenSpellblade : BaseKnife
+	{
+		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 14; } }
+		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; } } // TODO
+		public override int InitMaxHits{ get{ return 60; } } // TODO
+
+		[Constructable]
+		public ElvenSpellblade() : base( 0x2D20 )
+		{
+			Weight = 5.0;
+			Layer = Layer.TwoHanded;
+		}
+
+		public ElvenSpellblade( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/Leafblade.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x2D22, 0x2D2E )]
+	public class Leafblade : BaseKnife
+	{
+		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 13; } }
+		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
+
+		[Constructable]
+		public Leafblade() : base( 0x2D22 )
+		{
+			Weight = 8.0;
+		}
+
+		public Leafblade( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/MagicalShortbow.cs

@@ -0,0 +1,57 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x2D2B, 0x2D1F )]
+	public class MagicalShortbow : BaseRanged
+	{
+		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.LightningArrow; } }
+		public override WeaponAbility SecondaryAbility{ get{ return WeaponAbility.PsychicAttack; } }
+
+		public override int AosStrengthReq{ get{ return 45; } }
+		public override int AosMinDamage{ get{ return 9; } }
+		public override int AosMaxDamage{ get{ return 13; } }
+		public override int AosSpeed{ get{ return 38; } }
+		public override float MlSpeed{ get{ return 3.00f; } }
+
+		public override int OldStrengthReq{ get{ return 45; } }
+		public override int OldMinDamage{ get{ return 9; } }
+		public override int OldMaxDamage{ get{ return 13; } }
+		public override int OldSpeed{ get{ return 38; } }
+
+		public override int DefMaxRange{ get{ return 10; } }
+
+		public override int InitMinHits{ get{ return 41; } }
+		public override int InitMaxHits{ get{ return 90; } }
+
+		[Constructable]
+		public MagicalShortbow() : base( 0x2D2B )
+		{
+			Weight = 6.0;
+		}
+
+		public MagicalShortbow( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/OrnateAxe.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x2D28, 0x2D34 )]
+	public class OrnateAxe : BaseAxe
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.Disarm; } }
+		public override WeaponAbility SecondaryAbility{ get{ return WeaponAbility.CrushingBlow; } }
+
+		public override int AosStrengthReq{ get{ return 45; } }
+		public override int AosMinDamage{ get{ return 18; } }
+		public override int AosMaxDamage{ get{ return 20; } }
+		public override int AosSpeed{ get{ return 26; } }
+		public override float MlSpeed{ get{ return 3.50f; } }
+
+		public override int OldStrengthReq{ get{ return 45; } }
+		public override int OldMinDamage{ get{ return 18; } }
+		public override int OldMaxDamage{ get{ return 20; } }
+		public override int OldSpeed{ get{ return 26; } }
+
+		public override int DefMissSound{ get{ return 0x239; } }
+
+		public override int InitMinHits{ get{ return 30; } }
+		public override int InitMaxHits{ get{ return 60; } }
+
+		[Constructable]
+		public OrnateAxe() : base( 0x2D28 )
+		{
+			Weight = 12.0;
+			Layer = Layer.TwoHanded;
+		}
+
+		public OrnateAxe( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/RadiantScimitar.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x2D33, 0x2D27 )]
+	public class RadiantScimitar : BaseSword
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.WhirlwindAttack; } }
+		public override WeaponAbility SecondaryAbility{ get{ return WeaponAbility.Bladeweave; } }
+
+		public override int AosStrengthReq{ get{ return 20; } }
+		public override int AosMinDamage{ get{ return 12; } }
+		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 20; } }
+		public override int OldMinDamage{ get{ return 12; } }
+		public override int OldMaxDamage{ get{ return 14; } }
+		public override int OldSpeed{ get{ return 43; } }
+
+		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; } }
+
+		[Constructable]
+		public RadiantScimitar() : base( 0x2D33 )
+		{
+			Weight = 9.0;
+		}
+
+		public RadiantScimitar( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/RuneBlade.cs

@@ -0,0 +1,55 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x2D32, 0x2D26 )]
+	public class RuneBlade : BaseSword
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.Disarm; } }
+		public override WeaponAbility SecondaryAbility{ get{ return WeaponAbility.Bladeweave; } }
+
+		public override int AosStrengthReq{ get{ return 30; } }
+		public override int AosMinDamage{ get{ return 15; } }
+		public override int AosMaxDamage{ get{ return 17; } }
+		public override int AosSpeed{ get{ return 35; } }
+		public override float MlSpeed{ get{ return 3.00f; } }
+
+		public override int OldStrengthReq{ get{ return 30; } }
+		public override int OldMinDamage{ get{ return 15; } }
+		public override int OldMaxDamage{ get{ return 17; } }
+		public override int OldSpeed{ get{ return 35; } }
+
+		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; } }
+
+		[Constructable]
+		public RuneBlade() : base( 0x2D32 )
+		{
+			Weight = 7.0;
+			Layer = Layer.TwoHanded;
+		}
+
+		public RuneBlade( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/WarCleaver.cs

@@ -0,0 +1,58 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x2D2F, 0x2D23 )]
+	public class WarCleaver : BaseKnife
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.Disarm; } }
+		public override WeaponAbility SecondaryAbility{ get{ return WeaponAbility.Bladeweave; } }
+
+		public override int AosStrengthReq{ get{ return 15; } }
+		public override int AosMinDamage{ get{ return 9; } }
+		public override int AosMaxDamage{ get{ return 11; } }
+		public override int AosSpeed{ get{ return 48; } }
+		public override float MlSpeed{ get{ return 2.25f; } }
+
+		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 48; } }
+
+		public override int DefHitSound{ get{ return 0x23B; } }
+		public override int DefMissSound{ get{ return 0x239; } }
+
+		public override int InitMinHits{ get{ return 30; } } // TODO
+		public override int InitMaxHits{ get{ return 60; } } // TODO
+
+		public override SkillName DefSkill{ get{ return SkillName.Fencing; } }
+		public override WeaponType DefType{ get{ return WeaponType.Piercing; } }
+		public override WeaponAnimation DefAnimation{ get{ return WeaponAnimation.Pierce1H; } }
+
+		[Constructable]
+		public WarCleaver() : base( 0x2D2F )
+		{
+			Weight = 10.0;
+		}
+
+		public WarCleaver( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/ML Weapons/WildStaff.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x2D25, 0x2D31 )]
+	public class WildStaff : BaseStaff
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.Block; } }
+		public override WeaponAbility SecondaryAbility{ get{ return WeaponAbility.ForceOfNature; } }
+
+		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 48; } }
+		public override float MlSpeed{ get{ return 2.25f; } }
+
+		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 48; } }
+
+		public override int InitMinHits{ get{ return 30; } }
+		public override int InitMaxHits{ get{ return 60; } }
+
+		[Constructable]
+		public WildStaff() : base( 0x2D25 )
+		{
+			Weight = 8.0;
+		}
+
+		public WildStaff( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/Maces/BaseBashing.cs

@@ -0,0 +1,60 @@
+using System;
+using Server;
+using Server.Items;
+
+namespace Server.Items
+{
+	public abstract class BaseBashing : BaseMeleeWeapon
+	{
+		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 BaseBashing( int itemID ) : base( itemID )
+		{
+		}
+
+		public BaseBashing( 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 OnHit( Mobile attacker, Mobile defender, double damageBonus )
+		{
+			base.OnHit( attacker, defender, damageBonus );
+
+			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) && Layer == Layer.TwoHanded && attacker.Skills[SkillName.Anatomy].Value >= 80 && (attacker.Skills[SkillName.Anatomy].Value / 400.0) >= Utility.RandomDouble() && Engines.ConPVP.DuelContext.AllowSpecialAbility(attacker, "Crushing Blow", false))
+			{
+				damage *= 1.5;
+
+				attacker.SendMessage( "You deliver a crushing blow!" ); // Is this not localized?
+				attacker.PlaySound( 0x11C );
+			}
+
+			return damage;
+		}
+	}
+}

Scripts/Items/Weapons/Maces/Club.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x13b4, 0x13b3 )]
+	public class Club : BaseBashing
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.ShadowStrike; } }
+		public override WeaponAbility SecondaryAbility{ get{ return WeaponAbility.Dismount; } }
+
+		public override int AosStrengthReq{ get{ return 40; } }
+		public override int AosMinDamage{ get{ return 11; } }
+		public override int AosMaxDamage{ get{ return 13; } }
+		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; } }
+
+		[Constructable]
+		public Club() : base( 0x13B4 )
+		{
+			Weight = 9.0;
+		}
+
+		public Club( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Maces/EmeraldMace.cs

@@ -0,0 +1,34 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class EmeraldMace : DiamondMace
+	{
+		public override int LabelNumber{ get{ return 1073530; } } // emerald mace
+
+		[Constructable]
+		public EmeraldMace()
+		{
+			WeaponAttributes.ResistPoisonBonus = 5;
+		}
+
+		public EmeraldMace( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/Maces/FireworksWand.cs

@@ -0,0 +1,138 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class FireworksWand : MagicWand
+	{
+		public override int LabelNumber{ get{ return 1041424; } } // a fireworks wand
+
+		private int m_Charges;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int Charges
+		{
+			get{ return m_Charges; }
+			set{ m_Charges = value; InvalidateProperties(); }
+		}
+
+		[Constructable]
+		public FireworksWand() : this( 100 )
+		{
+		}
+
+		[Constructable]
+		public FireworksWand( int charges )
+		{
+			m_Charges = charges;
+			LootType = LootType.Blessed;
+		}
+
+		public FireworksWand( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void AddNameProperties( ObjectPropertyList list )
+		{
+			base.AddNameProperties( list );
+
+			list.Add( 1060741, m_Charges.ToString() ); // charges: ~1_val~
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			BeginLaunch( from, true );
+		}
+
+		public void BeginLaunch( Mobile from, bool useCharges )
+		{
+			Map map = from.Map;
+
+			if ( map == null || map == Map.Internal )
+				return;
+
+			if ( useCharges )
+			{
+				if ( Charges > 0 )
+				{
+					--Charges;
+				}
+				else
+				{
+					from.SendLocalizedMessage( 502412 ); // There are no charges left on that item.
+					return;
+				}
+			}
+
+			from.SendLocalizedMessage( 502615 ); // You launch a firework!
+
+			Point3D ourLoc = 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 } );
+		}
+
+		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 );
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+
+			writer.Write( (int) m_Charges );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 0:
+				{
+					m_Charges = reader.ReadInt();
+					break;
+				}
+			}
+		}
+	}
+}

Scripts/Items/Weapons/Maces/HammerPick.cs

@@ -0,0 +1,52 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x143D, 0x143C )]
+	public class HammerPick : BaseBashing
+	{
+		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 15; } }
+		public override int AosMaxDamage{ get{ return 17; } }
+		public override int AosSpeed{ get{ return 28; } }
+		public override float MlSpeed{ get{ return 3.75f; } }
+
+		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; } }
+
+		[Constructable]
+		public HammerPick() : base( 0x143D )
+		{
+			Weight = 9.0;
+			Layer = Layer.OneHanded;
+		}
+
+		public HammerPick( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Maces/Mace.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0xF5C, 0xF5D )]
+	public class Mace : BaseBashing
+	{
+		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 12; } }
+		public override int AosMaxDamage{ get{ return 14; } }
+		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; } }
+
+		[Constructable]
+		public Mace() : base( 0xF5C )
+		{
+			Weight = 14.0;
+		}
+
+		public Mace( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Maces/MagicWand.cs

@@ -0,0 +1,50 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class MagicWand : BaseBashing
+	{
+		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; } }
+
+		[Constructable]
+		public MagicWand() : base( 0xDF2 )
+		{
+			Weight = 1.0;
+		}
+
+		public MagicWand( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Maces/Maul.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x143B, 0x143A )]
+	public class Maul : BaseBashing
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.CrushingBlow; } }
+		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 16; } }
+		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; } }
+
+		[Constructable]
+		public Maul() : base( 0x143B )
+		{
+			Weight = 10.0;
+		}
+
+		public Maul( 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();
+
+			if ( Weight == 14.0 )
+				Weight = 10.0;
+		}
+	}
+}

Scripts/Items/Weapons/Maces/RubyMace.cs

@@ -0,0 +1,34 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class RubyMace : DiamondMace
+	{
+		public override int LabelNumber{ get{ return 1073529; } } // ruby mace
+
+		[Constructable]
+		public RubyMace()
+		{
+			Attributes.WeaponDamage = 5;
+		}
+
+		public RubyMace( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/Maces/SapphireMace.cs

@@ -0,0 +1,34 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class SapphireMace : DiamondMace
+	{
+		public override int LabelNumber{ get{ return 1073531; } } // sapphire mace
+
+		[Constructable]
+		public SapphireMace()
+		{
+			WeaponAttributes.ResistEnergyBonus = 5;
+		}
+
+		public SapphireMace( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/Maces/Scepter.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x26BC, 0x26C6 )]
+	public class Scepter : BaseBashing
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.CrushingBlow; } }
+		public override WeaponAbility SecondaryAbility{ get{ return WeaponAbility.MortalStrike; } }
+
+		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 30; } }
+		public override float MlSpeed{ get{ return 3.50f; } }
+
+		public override int OldStrengthReq{ get{ return 40; } }
+		public override int OldMinDamage{ get{ return 14; } }
+		public override int OldMaxDamage{ get{ return 17; } }
+		public override int OldSpeed{ get{ return 30; } }
+
+		public override int InitMinHits{ get{ return 31; } }
+		public override int InitMaxHits{ get{ return 110; } }
+
+		[Constructable]
+		public Scepter() : base( 0x26BC )
+		{
+			Weight = 8.0;
+		}
+
+		public Scepter( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Maces/SilverEtchedMace.cs

@@ -0,0 +1,34 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class SilverEtchedMace : DiamondMace
+	{
+		public override int LabelNumber{ get{ return 1073532; } } // silver-etched mace
+
+		[Constructable]
+		public SilverEtchedMace()
+		{
+			Slayer = SlayerName.Exorcism;
+		}
+
+		public SilverEtchedMace( Serial serial ) : base( serial )
+		{
+		}
+
+		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/Weapons/Maces/WarHammer.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x1439, 0x1438 )]
+	public class WarHammer : BaseBashing
+	{
+		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 18; } }
+		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; } }
+
+		[Constructable]
+		public WarHammer() : base( 0x1439 )
+		{
+			Weight = 10.0;
+			Layer = Layer.TwoHanded;
+		}
+
+		public WarHammer( 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();
+		}
+	}
+}

Scripts/Items/Weapons/Maces/WarMace.cs

@@ -0,0 +1,51 @@
+using System;
+using Server.Network;
+using Server.Items;
+
+namespace Server.Items
+{
+	[FlipableAttribute( 0x1407, 0x1406 )]
+	public class WarMace : BaseBashing
+	{
+		public override WeaponAbility PrimaryAbility{ get{ return WeaponAbility.CrushingBlow; } }
+		public override WeaponAbility SecondaryAbility{ get{ return WeaponAbility.MortalStrike; } }
+
+		public override int AosStrengthReq{ get{ return 80; } }
+		public override int AosMinDamage{ get{ return 16; } }
+		public override int AosMaxDamage{ get{ return 17; } }
+		public override int AosSpeed{ get{ return 26; } }
+		public override float MlSpeed{ get{ return 4.00f; } }
+
+		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; } }
+
+		[Constructable]
+		public WarMace() : base( 0x1407 )
+		{
+			Weight = 17.0;
+		}
+
+		public WarMace( 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();
+		}
+	}
+}