Overwrite

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

Scripts/Items/Equipment/Weapons/Fists.cs

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