Overwrite

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

Scripts/Items/Internal/ItemSockets/Caddellite.cs

@@ -0,0 +1,197 @@
+using System;
+
+using Server;
+using Server.Mobiles;
+using Server.Engines.Craft;
+using Server.Spells;
+using Server.Engines.Points;
+using Server.Engines.Khaldun;
+using Server.Engines.Harvest;
+
+namespace Server.Items
+{
+    public class Caddellite : ItemSocket
+    {
+        public Caddellite()
+        {
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            if (Owner != null && !(Owner is ICombatEquipment) && !(Owner is Spellbook))
+            {
+                list.Add(1158662); // Caddellite Infused
+            }
+        }
+
+        public static void Initialize()
+        {
+            EventSink.Login += OnLogin;
+        }
+
+        public static bool CheckDamage(Mobile from, Server.DamageType type)
+        {
+            if (from is BaseCreature)
+            {
+                if (KhaldunTastyTreat.UnderInfluence((BaseCreature)from))
+                {
+                    return true;
+                }
+
+                return false;
+            }
+            else if (from.Player)
+            {
+                Item damager = from.FindItemOnLayer(Layer.OneHanded);
+
+                if (damager == null)
+                {
+                    damager = from.FindItemOnLayer(Layer.TwoHanded);
+                }
+
+                if (damager != null && damager.HasSocket<Caddellite>())
+                {
+                    switch (type)
+                    {
+                        case Server.DamageType.Melee:
+                        case Server.DamageType.Ranged:
+                            return damager is BaseWeapon;
+                        default:
+                            return damager is Spellbook;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        public static bool IsCaddellite(Mobile from, Item item)
+        {
+            return PointsSystem.Khaldun.InSeason && item is ICaddelliteTool && SpellHelper.IsAnyT2A(from.Map, from.Location);
+        }
+
+        public static void OnHarvest(Mobile from, Item tool, HarvestSystem system, Item resource)
+        {
+            if(IsCaddellite(from, tool))
+            {
+                if (resource != null)
+                {
+                    resource.AttachSocket(new Caddellite());
+                }
+
+                if (0.005 > Utility.RandomDouble())
+                {
+                    if (from != null)
+                    {
+                        if (system == Fishing.System)
+                        {
+                            from.SendLocalizedMessage(1158664); // You discover a meteorite entangled in your line!
+                        }
+                        else if (system == Mining.System)
+                        {
+                            from.SendLocalizedMessage(1158663); // You discover a meteorite in the dirt!
+                        }
+                        else if (system == Lumberjacking.System)
+                        {
+                            from.SendLocalizedMessage(1158665); // You discover a meteorite in the tree!
+                        }
+
+                        from.AddToBackpack(new Meteorite());
+                    }
+                }
+            }
+        }
+
+        private static Rectangle2D _CraftRec = new Rectangle2D(6017, 3743, 8, 8);
+        private static Rectangle2D _CookingRec = new Rectangle2D(6002, 3779, 7, 2);
+        private static Rectangle2D _ScribeRec = new Rectangle2D(5999, 3771, 5, 2);
+
+        public static void CheckWaterSource(Mobile from, BaseBeverage beverage, Item item)
+        {
+            if (from.Region.IsPartOf<KhaldunCampRegion>())
+            {
+                beverage.Content = BeverageType.Water;
+                beverage.Poison = null;
+                beverage.Poisoner = null;
+
+                beverage.Quantity = beverage.MaxQuantity;
+
+                from.SendLocalizedMessage(1010089); // You fill the container with water.
+
+                beverage.AttachSocket(new Caddellite());
+            }
+        }
+
+        public static void TryInfuse(Mobile from, Item item, CraftSystem system)
+        {
+            Rectangle2D rec;
+
+            if (system == DefCooking.CraftSystem || system == DefAlchemy.CraftSystem)
+            {
+                rec = _CookingRec;
+            }
+            else if (system == DefInscription.CraftSystem)
+            {
+                rec = _ScribeRec;
+            }
+            else
+            {
+                rec = _CraftRec;
+            }
+
+            if (rec.Contains(from))
+            {
+                item.AttachSocket(new Caddellite());
+            }
+        }
+
+        public static void UpdateBuff(Mobile m)
+        {
+            BaseCreature pet = KhaldunTastyTreat.GetPetUnderEffects(m);
+            Caddellite equipped = null;
+            var item = m.FindItemOnLayer(Layer.TwoHanded);
+            
+            if (item == null)
+            {
+                item = m.FindItemOnLayer(Layer.OneHanded);
+            }
+
+            if (item != null)
+            {
+                equipped = item.GetSocket<Caddellite>();
+            }
+
+            if (equipped == null && pet == null)
+            {
+                BuffInfo.RemoveBuff(m, BuffIcon.CaddelliteInfused);
+            }
+            else
+            {
+                BuffInfo.AddBuff(m, new BuffInfo(BuffIcon.CaddelliteInfused, 1158662, 1158677,
+                    String.Format("{0}\t{1}\t{2}\t{3}", equipped != null && equipped.Owner is BaseWeapon ? "100" : "0", equipped != null && equipped.Owner is Spellbook ? "100" : "0", pet != null ? pet.Name : "", pet != null ? "100" : "0")));
+            }
+        }
+
+        public static void OnLogin(LoginEventArgs e)
+        {
+            var pm = e.Mobile as PlayerMobile;
+
+            if (pm != null)
+            {
+                UpdateBuff(pm);
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(Item owner, GenericReader reader)
+        {
+            base.Deserialize(owner, reader);
+            reader.ReadInt(); // version
+        }
+    }
+}

Scripts/Items/Internal/ItemSockets/EnchantedHotItem.cs

@@ -0,0 +1,173 @@
+using System;
+
+namespace Server.Items
+{
+    public class EnchantedHotItemSocket : ItemSocket
+    {
+        public Container Container { get; set; }
+
+        public override TimeSpan TickDuration { get { return TimeSpan.FromSeconds(3); } }
+
+        public EnchantedHotItemSocket()
+        {
+        }
+
+        public EnchantedHotItemSocket(Container c)
+        {
+            Container = c;
+
+            BeginTimer();
+        }
+
+        protected override void OnTick()
+        {
+            if (Owner == null || Owner.Deleted)
+            {
+                EndTimer();
+            }
+            else if (Owner.RootParent is Mobile)
+            {
+                if (((Mobile)Owner.RootParent).Region.IsPartOf("Wrong"))
+                {
+                    AOS.Damage((Mobile)Owner.RootParent, Utility.RandomMinMax(10, 13), 0, 100, 0, 0, 0);
+
+                    if (0.2 > Utility.RandomDouble())
+                    {
+                        ((Mobile)Owner.RootParent).SendLocalizedMessage(1152086); // Ouch! These stolen items are hot!
+                    }
+                }
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            list.Add(1152081); // Enchanted Hot Item
+            list.Add(1152082); // (Escape from dungeon to remove spell)
+        }
+
+        public override void OnRemoved()
+        {
+            if (Owner is BaseWeapon)
+            {
+                Owner.Hue = ((BaseWeapon)Owner).GetElementalDamageHue();
+            }
+            else
+            {
+                Owner.Hue = 0;
+            }
+        }
+
+        public override void OnAfterDuped(ItemSocket oldSocket)
+        {
+            if (oldSocket is EnchantedHotItemSocket)
+            {
+                Container = ((EnchantedHotItemSocket)oldSocket).Container;
+            }
+        }
+
+        public static void OnEnterRegion(OnEnterRegionEventArgs e)
+        {
+            Mobile m = e.From;
+
+            if (!m.Player || e.OldRegion == null || e.NewRegion == null || m.Backpack == null)
+                return;
+
+            if (e.OldRegion.IsPartOf("Wrong") && !e.NewRegion.IsPartOf("Wrong"))
+            {
+                bool found = false;
+
+                m.Backpack.Items.IterateReverse(i =>
+                {
+                    var socket = i.GetSocket<EnchantedHotItemSocket>();
+
+                    if (socket != null)
+                    {
+                        found = true;
+                        socket.Remove();
+                    }
+                });
+
+                if (found)
+                {
+                    m.SendLocalizedMessage(1152085); // The curse is removed from the item you stole!
+                }
+            }
+        }
+
+        public static bool CheckDrop(Mobile from, Container droppedTo, Item dropped)
+        {
+            var socket = dropped.GetSocket<EnchantedHotItemSocket>();
+
+            if (socket != null)
+            {
+                Container c = socket.Container;
+
+                if (droppedTo != c && droppedTo != from.Backpack)
+                {
+                    from.SendLocalizedMessage(1152083); // The stolen item magically returns to the trunk where you found it.
+
+                    if (c != null)
+                    {
+                        c.DropItem(dropped);
+                    }
+                    else
+                    {
+                        dropped.Delete();
+                    }
+
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static bool CheckDrop(Mobile from, Item dropped)
+        {
+            var socket = dropped.GetSocket<EnchantedHotItemSocket>();
+
+            if (socket != null)
+            {
+                Container c = socket.Container;
+
+                from.SendLocalizedMessage(1152083); // The stolen item magically returns to the trunk where you found it.
+
+                if (c != null)
+                {
+                    c.DropItem(dropped);
+                }
+                else
+                {
+                    dropped.Delete();
+                }
+
+                return false;
+            }
+
+            return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write(Container);
+        }
+
+        public override void Deserialize(Item owner, GenericReader reader)
+        {
+            base.Deserialize(owner, reader);
+            reader.ReadInt(); // version
+
+            Container = reader.ReadItem() as Container;
+
+            BeginTimer();
+        }
+
+        public static void Initialize()
+        {
+            EventSink.OnEnterRegion += OnEnterRegion;
+        }
+    }
+}

Scripts/Items/Internal/ItemSockets/HonestyItem.cs

@@ -0,0 +1,145 @@
+using System;
+using Server.Services.Virtues;
+
+namespace Server.Items
+{
+    public class HonestyItemSocket : ItemSocket
+    {
+        public const int ExpireTime = 3;
+
+        public string HonestyRegion { get; set; }
+        public Mobile HonestyOwner { get; set; }
+        public Timer HonestyTimer { get; set; }
+        public DateTime HonestyPickup { get; set; }
+        public bool HonestyTimerTicking { get; set; }
+
+        public override TimeSpan TickDuration { get { return TimeSpan.FromSeconds(5); } }
+
+        public HonestyItemSocket()
+        {
+        }
+
+        public void StartHonestyTimer()
+        {
+            HonestyTimerTicking = true;
+
+            BeginTimer();
+        }
+
+        protected override void OnTick()
+        {
+            if ((HonestyPickup + TimeSpan.FromHours(ExpireTime)) < DateTime.UtcNow)
+            {
+                Remove();
+            }
+            else
+            {
+                Owner.InvalidateProperties();
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            if (HonestyPickup != DateTime.MinValue)
+            {
+                int minutes = (int)(HonestyPickup + TimeSpan.FromHours(3) - DateTime.UtcNow).TotalMinutes;
+                list.Add(1151914, minutes.ToString()); // Minutes remaining for credit: ~1_val~
+            }
+
+            list.Add(1151520); // lost item (Return to gain Honesty)
+        }
+
+        public override void OnRemoved()
+        {
+            if (Owner != null && !Owner.Deleted)
+            {
+                Owner.HonestyItem = false;
+
+                if (Owner.RootParent is Mobile)
+                {
+                    ((Mobile)Owner.RootParent).SendLocalizedMessage(1151519); // You claim the item as your own.  Finders keepers, losers weepers!
+                }
+            }
+        }
+
+        public override void OnAfterDuped(ItemSocket oldSocket)
+        {
+            if (oldSocket is HonestyItemSocket)
+            {
+                var honesty = oldSocket as HonestyItemSocket;
+
+                HonestyRegion = honesty.HonestyRegion;
+                HonestyOwner = honesty.HonestyOwner;
+                HonestyPickup = honesty.HonestyPickup;
+                HonestyTimerTicking = honesty.HonestyTimerTicking;
+
+                if (HonestyTimerTicking)
+                {
+                    BeginTimer();
+                }
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write(HonestyRegion);
+            writer.Write(HonestyOwner);
+            writer.Write(HonestyPickup);
+            writer.Write(HonestyTimerTicking);
+        }
+
+        public override void Deserialize(Item owner, GenericReader reader)
+        {
+            base.Deserialize(owner, reader);
+            reader.ReadInt(); // version
+
+            HonestyRegion = reader.ReadString();
+            HonestyOwner = reader.ReadMobile();
+            HonestyPickup = reader.ReadDateTime();
+            HonestyTimerTicking = reader.ReadBool();
+
+            Owner.HonestyItem = true;
+
+            if (HonestyTimerTicking)
+            {
+                BeginTimer();
+            }
+        }
+
+        public static void Initialize()
+        {
+            if (HonestyVirtue.Enabled)
+            {
+                EventSink.ContainerDroppedTo += OnDropped;
+            }
+        }
+
+        public static void OnDropped(ContainerDroppedToEventArgs e)
+        {
+            var dropped = e.Dropped;
+            var from = e.Mobile;
+
+            if (dropped != null)
+            {
+                var honestySocket = dropped.GetSocket<HonestyItemSocket>();
+
+                if (honestySocket != null && honestySocket.HonestyPickup == DateTime.MinValue)
+                {
+                    honestySocket.HonestyPickup = DateTime.UtcNow;
+                    honestySocket.StartHonestyTimer();
+
+                    if (honestySocket.HonestyOwner == null)
+                        Server.Services.Virtues.HonestyVirtue.AssignOwner(honestySocket);
+
+                    if (from != null)
+                    {
+                        from.SendLocalizedMessage(1151536); // You have three hours to turn this item in for Honesty credit, otherwise it will cease to be a quest item.
+                    }
+                }
+            }
+        }
+    }
+}

Scripts/Items/Internal/ItemSockets/SearingWeapon.cs

@@ -0,0 +1,110 @@
+using System;
+
+using Server.ContextMenus;
+
+namespace Server.Items
+{
+    public class SearingWeapon : ItemSocket
+    {
+        public bool Extinguished { get; set; } = true;
+
+        public SearingWeapon()
+        {
+        }
+
+        public SearingWeapon(BaseWeapon wep)
+        {
+            wep.NegativeAttributes.Brittle = 1;
+            wep.MaxHitPoints = 200;
+            wep.HitPoints = 200;
+            wep.Hue = 2500;
+        }
+
+        public override void OnRemoved()
+        {
+            if (Owner is BaseWeapon)
+            {
+                ((BaseWeapon)Owner).NegativeAttributes.Brittle = 0;
+                Owner.Hue = ((BaseWeapon)Owner).GetElementalDamageHue();
+            }
+        }
+
+        public static void OnWeaponRemoved(BaseWeapon wep)
+        {
+            var socket = wep.GetSocket<SearingWeapon>();
+
+            if (socket != null && !socket.Extinguished)
+            {
+                socket.Extinguished = true;
+                wep.Hue = 2500;
+            }
+        }
+
+        public void ToggleExtinguish(Mobile from)
+        {
+            if (Extinguished)
+            {
+                Extinguished = false;
+                Owner.Hue = 1174;
+
+                from.SendLocalizedMessage(1151175); // You ignite your weapon.
+            }
+            else
+            {
+                Extinguished = true;
+                Owner.Hue = 2500;
+
+                from.SendLocalizedMessage(1151176); // You extinguish your weapon.
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write(Extinguished);
+        }
+
+        public static bool CanSear(BaseWeapon weapon)
+        {
+            var socket = weapon.GetSocket<SearingWeapon>();
+
+            return socket != null && !socket.Extinguished;
+        }
+
+        public override void Deserialize(Item owner, GenericReader reader)
+        {
+            base.Deserialize(owner, reader);
+            reader.ReadInt(); // version
+
+            Extinguished = reader.ReadBool();
+        }
+
+        public class ToggleExtinguishEntry : ContextMenuEntry
+        {
+            public BaseWeapon Weapon { get; set; }
+            public Mobile From { get; set; }
+
+            public ToggleExtinguishEntry(Mobile from, BaseWeapon weapon)
+                : base(weapon.GetSocket<SearingWeapon>().Extinguished ? 1151173 : 1151174, -1)
+            {
+                From = from;
+                Weapon = weapon;
+            }
+
+            public override void OnClick()
+            {
+                if (Weapon.Parent == From)
+                {
+                    var socket = Weapon.GetSocket<SearingWeapon>();
+
+                    if (socket != null)
+                    {
+                        socket.ToggleExtinguish(From);
+                    }
+                }
+            }
+        }
+    }
+}

Scripts/Items/Internal/ItemSockets/SlayerSocket.cs

@@ -0,0 +1,73 @@
+using System;
+
+namespace Server.Items
+{
+    public class SlayerSocket : ItemSocket
+    {
+        public SlayerName Slayer { get; set; }
+
+        public SlayerSocket()
+        {
+        }
+
+        public SlayerSocket(SlayerName slayer, TimeSpan duration)
+            : base(duration)
+        {
+            Slayer = slayer;
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            list.Add(1155617); // Silvered
+        }
+
+        public override void OnRemoved()
+        {
+            if (Owner != null && !Owner.Deleted && Owner.RootParent is Mobile)
+            {
+                ((Mobile)Owner.RootParent).SendLocalizedMessage(1155618, String.IsNullOrEmpty(Owner.Name) ? String.Format("#{0}", Owner.LabelNumber) : Owner.Name); // Your ~1_name~'s Tincture of Silver has worn off.
+            }
+        }
+
+        public static SlayerName GetSlayer(Item item)
+        {
+            if (item == null)
+            {
+                return SlayerName.None;
+            }
+
+            var socket = item.GetSocket<SlayerSocket>();
+
+            if (socket != null)
+            {
+                return socket.Slayer;
+            }
+
+            return SlayerName.None;
+        }
+
+        public override void OnAfterDuped(ItemSocket oldSocket)
+        {
+            if (oldSocket is SlayerSocket)
+            {
+                Slayer = ((SlayerSocket)oldSocket).Slayer;
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write((int)Slayer);
+        }
+
+        public override void Deserialize(Item owner, GenericReader reader)
+        {
+            base.Deserialize(owner, reader);
+            reader.ReadInt(); // version
+
+            Slayer = (SlayerName)reader.ReadInt();
+        }
+    }
+}