Overwrite

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

Scripts/Items/Equipment/Instruments/BaseInstrument.cs

@@ -0,0 +1,746 @@
+using System;
+using System.Collections;
+using Server.Engines.Craft;
+using Server.Mobiles;
+using Server.Network;
+using Server.Targeting;
+
+namespace Server.Items
+{
+    public delegate void InstrumentPickedCallback(Mobile from, BaseInstrument instrument);
+
+    public abstract class BaseInstrument : Item, ISlayer, IQuality, IResource
+    {
+        public static readonly double MaxBardingDifficulty = 160.0;
+
+        private int m_WellSound, m_BadlySound;
+        private SlayerName m_Slayer, m_Slayer2;
+        private ItemQuality m_Quality;
+        private Mobile m_Crafter;
+        private int m_UsesRemaining;
+        private CraftResource m_Resource;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int SuccessSound
+        {
+            get
+            {
+                return m_WellSound;
+            }
+            set
+            {
+                m_WellSound = value;
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int FailureSound
+        {
+            get
+            {
+                return m_BadlySound;
+            }
+            set
+            {
+                m_BadlySound = value;
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public SlayerName Slayer
+        {
+            get
+            {
+                return m_Slayer;
+            }
+            set
+            {
+                m_Slayer = value;
+                InvalidateProperties();
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public SlayerName Slayer2
+        {
+            get
+            {
+                return m_Slayer2;
+            }
+            set
+            {
+                m_Slayer2 = value;
+                InvalidateProperties();
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public ItemQuality Quality
+        {
+            get
+            {
+                return m_Quality;
+            }
+            set
+            {
+                UnscaleUses();
+                m_Quality = value;
+                InvalidateProperties();
+                ScaleUses();
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool PlayerConstructed { get { return m_Crafter != null; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Mobile Crafter
+        {
+            get
+            {
+                return m_Crafter;
+            }
+            set
+            {
+                m_Crafter = value;
+                InvalidateProperties();
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public CraftResource Resource
+        {
+            get { return m_Resource; }
+            set
+            {
+                m_Resource = value;
+                Hue = CraftResources.GetHue(m_Resource);
+                InvalidateProperties();
+            }
+        }
+
+        public virtual int InitMinUses
+        {
+            get
+            {
+                return 350;
+            }
+        }
+        public virtual int InitMaxUses
+        {
+            get
+            {
+                return 450;
+            }
+        }
+
+        public virtual TimeSpan ChargeReplenishRate
+        {
+            get
+            {
+                return TimeSpan.FromMinutes(5.0);
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int UsesRemaining
+        {
+            get
+            {
+                CheckReplenishUses();
+                return m_UsesRemaining;
+            }
+            set
+            {
+                m_UsesRemaining = value;
+                InvalidateProperties();
+            }
+        }
+
+        private DateTime m_LastReplenished;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public DateTime LastReplenished
+        {
+            get
+            {
+                return m_LastReplenished;
+            }
+            set
+            {
+                m_LastReplenished = value;
+                CheckReplenishUses();
+            }
+        }
+
+        private bool m_ReplenishesCharges;
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool ReplenishesCharges
+        {
+            get
+            {
+                return m_ReplenishesCharges;
+            }
+            set 
+            {
+                if (value != m_ReplenishesCharges && value)
+                    m_LastReplenished = DateTime.UtcNow;
+
+                m_ReplenishesCharges = value; 
+            }
+        }
+
+        public void RandomInstrument()
+        {
+            switch (Utility.Random(3))
+            {
+                case 0:
+                    {
+                        ItemID = 0xEB2;
+                        SuccessSound = 0x45;
+                        FailureSound = 0x46;
+                        break;
+                    }
+                case 1:
+                    {
+                        ItemID = 0xEB3;
+                        SuccessSound = 0x4C;
+                        FailureSound = 0x4D;
+                        break;
+                    }
+                default:
+                    {
+                        ItemID = 0xE9C;
+                        SuccessSound = 0x38;
+                        FailureSound = 0x39;
+                        break;
+                    }
+            }
+        }
+
+        public void CheckReplenishUses()
+        {
+            CheckReplenishUses(true);
+        }
+
+        public void CheckReplenishUses(bool invalidate)
+        {
+            if (!m_ReplenishesCharges || m_UsesRemaining >= InitMaxUses)
+                return;
+
+            if (m_LastReplenished + ChargeReplenishRate < DateTime.UtcNow)
+            {
+                TimeSpan timeDifference = DateTime.UtcNow - m_LastReplenished;
+
+                m_UsesRemaining = Math.Min(m_UsesRemaining + (int)(timeDifference.Ticks / ChargeReplenishRate.Ticks), InitMaxUses);	//How rude of TimeSpan to not allow timespan division.
+                m_LastReplenished = DateTime.UtcNow;
+
+                if (invalidate)
+                    InvalidateProperties();
+            }
+        }
+
+        public void ScaleUses()
+        {
+            UsesRemaining = (UsesRemaining * GetUsesScalar()) / 100;
+            //InvalidateProperties();
+        }
+
+        public void UnscaleUses()
+        {
+            UsesRemaining = (UsesRemaining * 100) / GetUsesScalar();
+        }
+
+        public int GetUsesScalar()
+        {
+            if (m_Quality == ItemQuality.Exceptional)
+                return 200;
+
+            return 100;
+        }
+
+        public void ConsumeUse(Mobile from)
+        {
+            // TODO: Confirm what must happen here?
+            if (UsesRemaining > 1)
+            {
+                --UsesRemaining;
+            }
+            else
+            {
+                if (from != null)
+                    from.SendLocalizedMessage(502079); // The instrument played its last tune.
+
+                Delete();
+            }
+        }
+
+        private static readonly Hashtable m_Instruments = new Hashtable();
+
+        public static BaseInstrument GetInstrument(Mobile from)
+        {
+            BaseInstrument item = m_Instruments[from] as BaseInstrument;
+
+            if (item == null)
+                return null;
+
+            if (!item.IsChildOf(from.Backpack))
+            {
+                m_Instruments.Remove(from);
+                return null;
+            }
+
+            return item;
+        }
+
+        public static int GetBardRange(Mobile bard, SkillName skill)
+        {
+            return 8 + (int)(bard.Skills[skill].Value / 15);
+        }
+
+        public static void PickInstrument(Mobile from, InstrumentPickedCallback callback)
+        {
+            BaseInstrument instrument = GetInstrument(from);
+
+            if (instrument != null)
+            {
+                if (callback != null)
+                    callback(from, instrument);
+            }
+            else
+            {
+                from.SendLocalizedMessage(500617); // What instrument shall you play?
+                from.BeginTarget(1, false, TargetFlags.None, new TargetStateCallback(OnPickedInstrument), callback);
+            }
+        }
+
+        public static void OnPickedInstrument(Mobile from, object targeted, object state)
+        {
+            BaseInstrument instrument = targeted as BaseInstrument;
+
+            if (instrument == null)
+            {
+                from.SendLocalizedMessage(500619); // That is not a musical instrument.
+            }
+            else
+            {
+                SetInstrument(from, instrument);
+
+                InstrumentPickedCallback callback = state as InstrumentPickedCallback;
+
+                if (callback != null)
+                    callback(from, instrument);
+            }
+        }
+
+        public static bool IsMageryCreature(BaseCreature bc)
+        {
+            return (bc != null && bc.AI == AIType.AI_Mage && bc.Skills[SkillName.Magery].Base > 5.0);
+        }
+
+        public static bool IsFireBreathingCreature(BaseCreature bc)
+        {
+            if (bc == null)
+                return false;
+
+            var profile = bc.AbilityProfile;
+
+            if (profile != null)
+            {
+                return profile.HasAbility(SpecialAbility.DragonBreath);
+            }
+
+            return false;
+        }
+
+        public static bool IsPoisonImmune(BaseCreature bc)
+        {
+            return (bc != null && bc.PoisonImmune != null);
+        }
+
+        public static int GetPoisonLevel(BaseCreature bc)
+        {
+            if (bc == null)
+                return 0;
+
+            Poison p = bc.HitPoison;
+
+            if (p == null)
+                return 0;
+
+            return p.Level + 1;
+        }
+
+        public static double GetBaseDifficulty(Mobile targ)
+        {
+            /* Difficulty TODO: Add another 100 points for each of the following abilities:
+            - Radiation or Aura Damage (Heat, Cold etc.)
+            - Summoning Undead
+            */
+            double val = (targ.HitsMax * 1.6) + targ.StamMax + targ.ManaMax;
+
+            val += targ.SkillsTotal / 10;
+
+            BaseCreature bc = targ as BaseCreature;
+
+            if (IsMageryCreature(bc))
+                val += 100;
+
+            if (IsFireBreathingCreature(bc))
+                val += 100;
+
+            if (IsPoisonImmune(bc))
+                val += 100;
+
+            if (targ is VampireBat || targ is VampireBatFamiliar)
+                val += 100;
+
+            val += GetPoisonLevel(bc) * 20;
+
+            if (val > 700)
+                val = 700 + (int)((val - 700) * (3.0 / 11));
+
+            val /= 10;
+
+            if (bc != null && bc.IsParagon)
+                val += 40.0;
+
+            if (Core.SE && val > MaxBardingDifficulty)
+                val = MaxBardingDifficulty;
+
+            return val;
+        }
+
+        public double GetDifficultyFor(Mobile targ)
+        {
+            double val = GetBaseDifficulty(targ);
+
+            if (m_Quality == ItemQuality.Exceptional)
+                val -= 5.0; // 10%
+
+            if (m_Slayer != SlayerName.None)
+            {
+                SlayerEntry entry = SlayerGroup.GetEntryByName(m_Slayer);
+
+                if (entry != null)
+                {
+                    if (entry.Slays(targ))
+                        val -= 10.0; // 20%
+                    else if (entry.Group.OppositionSuperSlays(targ))
+                        val += 10.0; // -20%
+                }
+            }
+
+            if (m_Slayer2 != SlayerName.None)
+            {
+                SlayerEntry entry = SlayerGroup.GetEntryByName(m_Slayer2);
+
+                if (entry != null)
+                {
+                    if (entry.Slays(targ))
+                        val -= 10.0; // 20%
+                    else if (entry.Group.OppositionSuperSlays(targ))
+                        val += 10.0; // -20%
+                }
+            }
+
+            if (m_Slayer == SlayerName.None && m_Slayer2 == SlayerName.None)
+            {
+                SlayerEntry entry = SlayerGroup.GetEntryByName(SlayerSocket.GetSlayer(this));
+
+                if (entry != null)
+                {
+                    if (entry.Slays(targ))
+                        val -= 10.0; // 20%
+                    else if (entry.Group.OppositionSuperSlays(targ))
+                        val += 10.0; // -20%
+                }
+            }
+
+            return val;
+        }
+
+        public static void SetInstrument(Mobile from, BaseInstrument item)
+        {
+            m_Instruments[from] = item;
+        }
+
+        public BaseInstrument()
+        {
+            RandomInstrument();
+
+            UsesRemaining = Utility.RandomMinMax(InitMinUses, InitMaxUses);
+        }
+
+        public BaseInstrument(int itemID, int wellSound, int badlySound)
+            : base(itemID)
+        {
+            m_WellSound = wellSound;
+            m_BadlySound = badlySound;
+
+            UsesRemaining = Utility.RandomMinMax(InitMinUses, InitMaxUses);
+        }
+
+        public override void AddCraftedProperties(ObjectPropertyList list)
+        {
+            if (m_Crafter != null)
+                list.Add(1050043, m_Crafter.TitleName); // crafted by ~1_NAME~
+
+            if (m_Quality == ItemQuality.Exceptional)
+                list.Add(1060636); // exceptional
+        }
+
+        public override void AddUsesRemainingProperties(ObjectPropertyList list)
+        {
+            list.Add(1060584, UsesRemaining.ToString()); // uses remaining: ~1_val~
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            int oldUses = m_UsesRemaining;
+            CheckReplenishUses(false);
+
+            base.GetProperties(list);
+
+            if (m_ReplenishesCharges)
+                list.Add(1070928); // Replenish Charges
+
+            if (m_Slayer != SlayerName.None)
+            {
+                SlayerEntry entry = SlayerGroup.GetEntryByName(m_Slayer);
+                if (entry != null)
+                    list.Add(entry.Title);
+            }
+
+            if (m_Slayer2 != SlayerName.None)
+            {
+                SlayerEntry entry = SlayerGroup.GetEntryByName(m_Slayer2);
+                if (entry != null)
+                    list.Add(entry.Title);
+            }
+
+            if (!CraftResources.IsStandard(m_Resource))
+            {
+                int num = CraftResources.GetLocalizationNumber(m_Resource);
+
+                if (num > 0)
+                    list.Add(num);
+                else
+                    list.Add(CraftResources.GetName(m_Resource));
+            }
+
+            if (m_UsesRemaining != oldUses)
+                Timer.DelayCall(TimeSpan.Zero, new TimerCallback(InvalidateProperties));
+        }
+
+        public override void OnSingleClick(Mobile from)
+        {
+            ArrayList attrs = new ArrayList();
+
+            if (DisplayLootType)
+            {
+                if (LootType == LootType.Blessed)
+                    attrs.Add(new EquipInfoAttribute(1038021)); // blessed
+                else if (LootType == LootType.Cursed)
+                    attrs.Add(new EquipInfoAttribute(1049643)); // cursed
+            }
+
+            if (m_Quality == ItemQuality.Exceptional)
+                attrs.Add(new EquipInfoAttribute(1018305 - (int)m_Quality));
+
+            if (m_ReplenishesCharges)
+                attrs.Add(new EquipInfoAttribute(1070928)); // Replenish Charges
+
+            // TODO: Must this support item identification?
+            if (m_Slayer != SlayerName.None)
+            {
+                SlayerEntry entry = SlayerGroup.GetEntryByName(m_Slayer);
+                if (entry != null)
+                    attrs.Add(new EquipInfoAttribute(entry.Title));
+            }
+
+            if (m_Slayer2 != SlayerName.None)
+            {
+                SlayerEntry entry = SlayerGroup.GetEntryByName(m_Slayer2);
+                if (entry != null)
+                    attrs.Add(new EquipInfoAttribute(entry.Title));
+            }
+
+            int number;
+
+            if (Name == null)
+            {
+                number = LabelNumber;
+            }
+            else
+            {
+                LabelTo(from, Name);
+                number = 1041000;
+            }
+
+            if (attrs.Count == 0 && Crafter == null && Name != null)
+                return;
+
+            EquipmentInfo eqInfo = new EquipmentInfo(number, m_Crafter, false, (EquipInfoAttribute[])attrs.ToArray(typeof(EquipInfoAttribute)));
+
+            from.Send(new DisplayEquipmentInfo(this, eqInfo));
+        }
+
+        public BaseInstrument(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)4); // version
+
+            writer.Write((int)m_Resource);
+
+            writer.Write(m_ReplenishesCharges);
+            if (m_ReplenishesCharges)
+                writer.Write(m_LastReplenished);
+
+            writer.Write(m_Crafter);
+
+            writer.WriteEncodedInt((int)m_Quality);
+            writer.WriteEncodedInt((int)m_Slayer);
+            writer.WriteEncodedInt((int)m_Slayer2);
+
+            writer.WriteEncodedInt((int)UsesRemaining);
+
+            writer.WriteEncodedInt((int)m_WellSound);
+            writer.WriteEncodedInt((int)m_BadlySound);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 4:
+                    {
+                        m_Resource = (CraftResource)reader.ReadInt();
+                        goto case 3;
+                    }
+                case 3:
+                    {
+                        m_ReplenishesCharges = reader.ReadBool();
+
+                        if (m_ReplenishesCharges)
+                            m_LastReplenished = reader.ReadDateTime();
+
+                        goto case 2;
+                    }
+                case 2:
+                    {
+                        m_Crafter = reader.ReadMobile();
+
+                        m_Quality = (ItemQuality)reader.ReadEncodedInt();
+                        m_Slayer = (SlayerName)reader.ReadEncodedInt();
+                        m_Slayer2 = (SlayerName)reader.ReadEncodedInt();
+
+                        UsesRemaining = reader.ReadEncodedInt();
+
+                        m_WellSound = reader.ReadEncodedInt();
+                        m_BadlySound = reader.ReadEncodedInt();
+					
+                        break;
+                    }
+                case 1:
+                    {
+                        m_Crafter = reader.ReadMobile();
+
+                        m_Quality = (ItemQuality)reader.ReadEncodedInt();
+                        m_Slayer = (SlayerName)reader.ReadEncodedInt();
+
+                        UsesRemaining = reader.ReadEncodedInt();
+
+                        m_WellSound = reader.ReadEncodedInt();
+                        m_BadlySound = reader.ReadEncodedInt();
+
+                        break;
+                    }
+                case 0:
+                    {
+                        m_WellSound = reader.ReadInt();
+                        m_BadlySound = reader.ReadInt();
+                        UsesRemaining = Utility.RandomMinMax(InitMinUses, InitMaxUses);
+
+                        break;
+                    }
+            }
+
+            CheckReplenishUses();
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (!from.InRange(GetWorldLocation(), 1))
+            {
+                from.SendLocalizedMessage(500446); // That is too far away.
+            }
+            else if (from.BeginAction(typeof(BaseInstrument)))
+            {
+                SetInstrument(from, this);
+
+                Timer.DelayCall(TimeSpan.FromMilliseconds(1000), () =>
+                {
+                    from.EndAction(typeof(BaseInstrument));
+                });
+
+                if (CheckMusicianship(from))
+                    PlayInstrumentWell(from);
+                else
+                    PlayInstrumentBadly(from);
+            }
+            else
+            {
+                from.SendLocalizedMessage(500119); // You must wait to perform another action
+            }
+        }
+
+        public static bool CheckMusicianship(Mobile m)
+        {
+            m.CheckSkill(SkillName.Musicianship, 0.0, 120.0);
+
+            return ((m.Skills[SkillName.Musicianship].Value / 100) > Utility.RandomDouble());
+        }
+
+        public void PlayInstrumentWell(Mobile from)
+        {
+            from.PlaySound(m_WellSound);
+        }
+
+        public void PlayInstrumentBadly(Mobile from)
+        {
+            from.PlaySound(m_BadlySound);
+        }
+
+        #region ICraftable Members
+
+        public virtual int OnCraft(int quality, bool makersMark, Mobile from, CraftSystem craftSystem, Type typeRes, ITool tool, CraftItem craftItem, int resHue)
+        {
+            Quality = (ItemQuality)quality;
+
+            if (makersMark)
+                Crafter = from;
+
+            if (!craftItem.ForceNonExceptional)
+            {
+                if (typeRes == null)
+                    typeRes = craftItem.Resources.GetAt(0).ItemType;
+
+                Resource = CraftResources.GetFromType(typeRes);
+            }
+
+            return quality;
+        }
+        #endregion
+    }
+}