Overwrite

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

Scripts/Services/Seasonal Events/TreasuresOfDoom/Items/AncientClayVase.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+
+using Server;
+using Server.Network;
+using Server.Mobiles;
+using Server.Engines.Points;
+using Server.Engines.TreasuresOfDoom;
+using Server.SkillHandlers;
+
+namespace Server.Items
+{
+    public class AncientClayVase : Item, ICarvable
+    {
+        public override int LabelNumber { get { return 1155625; } } // Ancient Clay Vase
+        public bool DoomEvent { get; set; }
+
+        [Constructable]
+        public AncientClayVase()
+            : this(false)
+        {
+        }
+
+        public AncientClayVase(bool doom)
+            : base(0x42B3)
+        {
+            DoomEvent = doom;
+            Hue = 2676;
+            LootType = LootType.Blessed;
+        }
+
+        public bool Carve(Mobile from, Item item)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.PlaySound(Utility.Random(0x3E, 4));
+                from.PrivateOverheadMessage(MessageType.Regular, 0x3B2, 1155629, from.NetState); // *The vase shatters as you cut away the sealing wax!"
+
+                Delete();
+
+                if (0.5 > Utility.RandomDouble())
+                {
+                    from.AddToBackpack(new AncientParchment());
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public static void Initialize()
+        {
+            Stealing.ItemStolen += OnStolen;
+        }
+
+        public static void OnStolen(ItemStolenEventArgs e)
+        {
+            if (e.Item is AncientClayVase)
+            {
+                e.Mobile.PrivateOverheadMessage(MessageType.Regular, 0x3B2, 1155626, e.Mobile.NetState); // *It appears to be an ancient vase. The top is sealed with some kind of wax. A bladed item would perhaps be useful...*
+            }
+        }
+
+        public AncientClayVase(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write(DoomEvent);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            reader.ReadInt(); // version
+
+            DoomEvent = reader.ReadBool();
+
+            if (DoomEvent)
+            {
+                VaseSpawner.AddToSpawner(this);
+            }
+        }
+    }
+}

Scripts/Services/Seasonal Events/TreasuresOfDoom/Items/AncientParchment.cs

@@ -0,0 +1,50 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class AncientParchment : Item
+    {
+        public override int LabelNumber { get { return 1155627; } } // Ancient Parchment
+
+        [Constructable]
+        public AncientParchment()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public AncientParchment(int amount)
+            : base(0x2269)
+        {
+            LootType = LootType.Blessed;
+            Stackable = true;
+            Amount = amount;
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (IsChildOf(m.Backpack))
+            {
+                m.PrivateOverheadMessage(Server.Network.MessageType.Regular, 0x3B2, 1155628, m.NetState); // *The parchment appears heavily worn and in need of restoration by a skilled Scribe...*
+            }
+        }
+
+        public AncientParchment(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            reader.ReadInt(); // version
+        }
+    }
+}

Scripts/Services/Seasonal Events/TreasuresOfDoom/Items/AntiqueDocumentsKit.cs

@@ -0,0 +1,36 @@
+using System;
+
+using Server;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class AntiqueDocumentsKit : Item
+    {
+        public override int LabelNumber { get { return 1155630; } } // Antique Documents Kit
+
+        [Constructable]
+        public AntiqueDocumentsKit()
+            : base(0x1EBB)
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public AntiqueDocumentsKit(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            reader.ReadInt(); // version
+        }
+    }
+}

Scripts/Services/Seasonal Events/TreasuresOfDoom/Items/CloakOfLight.cs

@@ -0,0 +1,69 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    [Alterable(typeof(DefTailoring), typeof(WingArmorOfLight))]
+    public class CloakOfLight : Cloak
+	{
+		public override bool IsArtifact { get { return true; } }
+        [Constructable]
+        public CloakOfLight()
+        {
+			Attributes.NightSight = 1;
+            Attributes.RegenHits = 2;
+            Attributes.AttackChance = 5;
+        }
+
+        public CloakOfLight(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber { get{return 1155608;} }// Cloak of Light
+       
+        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();
+        }
+    }
+
+    public class WingArmorOfLight : GargishClothWingArmor
+    {
+        public override bool IsArtifact { get { return true; } }
+
+        [Constructable]
+        public WingArmorOfLight()
+        {
+            Attributes.NightSight = 1;
+            Attributes.RegenHits = 2;
+            Attributes.AttackChance = 5;
+        }
+
+        public WingArmorOfLight(Serial serial)
+            : base(serial)
+        {
+        }
+
+		public override int LabelNumber { get{return 1155683;} }// Wing Armor of Light
+  
+        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/Services/Seasonal Events/TreasuresOfDoom/Items/CrookOfHumility.cs

@@ -0,0 +1,39 @@
+using Server;
+
+namespace Server.Items
+{
+    public class CrookOfHumility : ShepherdsCrook
+    {
+        public override bool IsArtifact { get { return true; } }
+        public override int LabelNumber { get { return 1155624; } } // Crook of Humilty
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        [Constructable]
+        public CrookOfHumility()
+        {
+            Slayer3 = TalismanSlayerName.Wolf;
+            Attributes.SpellChanneling = 1;
+            Attributes.BonusInt = 10;
+            Attributes.WeaponDamage = 20;
+        }
+
+        public CrookOfHumility(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            reader.ReadInt(); // version
+        }
+    }
+}

Scripts/Services/Seasonal Events/TreasuresOfDoom/Items/DoomPlaque.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+
+using Server;
+using Server.Mobiles;
+using Server.Prompts;
+using Server.Network;
+using Server.Engines.Points;
+
+namespace Server.Items
+{
+    public class DoomPlaque : Item
+    {
+        public override int LabelNumber { get { return 1155662; } } // Plaque
+        public override bool ForceShowProperties { get { return true; } }
+
+        public Dictionary<Mobile, DateTime> NextMessage { get; set; }
+
+        public static readonly Point3D TeleportDestination = new Point3D(76, 224, 4);
+
+        [Constructable]
+        public DoomPlaque()
+            : base(0x4B20) 
+        {
+            Movable = false;
+            Hue = 2500;
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(GetWorldLocation(), 2))
+            {
+                m.Prompt = new DoomPlaquePrompt();
+            }
+        }
+
+        public override bool HandlesOnMovement { get { return true; } }
+
+        public override void OnMovement(Mobile m, Point3D oldLocation)
+        {
+            if (PointsSystem.TreasuresOfDoom.InSeason && m.Player && m.InRange(Location, 3) && m.InLOS(this))
+            {
+                if (NextMessage == null)
+                {
+                    NextMessage = new Dictionary<Mobile, DateTime>();
+                }
+                else
+                {
+                    CheckList();
+                }
+
+                if (!NextMessage.ContainsKey(m))
+                {
+                    m.PrivateOverheadMessage(MessageType.Regular, 0x3B2, 1155660, m.NetState); // *You examine the plaque...there appears to be a series of runic characters that are raised up...they look like buttons...*
+
+                    NextMessage[m] = DateTime.UtcNow + TimeSpan.FromMinutes(10);
+                }
+            }
+        }
+
+        private void CheckList()
+        {
+            if (NextMessage == null)
+            {
+                return;
+            }
+
+            var list = new List<Mobile>(NextMessage.Keys);
+
+            foreach (var m in list)
+            {
+                if (NextMessage[m] < DateTime.UtcNow)
+                {
+                    NextMessage.Remove(m);
+                }
+            }
+
+            ColUtility.Free(list);
+        }
+
+        private class DoomPlaquePrompt : Prompt
+        {
+            public override int MessageCliloc { get { return 1155661; } }
+
+            public DoomPlaquePrompt()
+            {
+            }
+
+            public override void OnResponse(Mobile from, string text)
+            {
+                if (!string.IsNullOrEmpty(text) && text.Trim().ToLower() == "wolfgang")
+                {
+                    Effects.SendLocationParticles(EffectItem.Create(from.Location, Map.Malas, EffectItem.DefaultDuration), 0x3728, 10, 10, 2023);
+                    from.MoveToWorld(TeleportDestination, Map.Malas);
+                    Effects.SendLocationParticles(EffectItem.Create(TeleportDestination, Map.Malas, EffectItem.DefaultDuration), 0x3728, 10, 10, 5023);
+                }
+                else
+                {
+                    from.SendLocalizedMessage(1155663); // Nothign Happens
+                }
+            }
+
+            public override void OnCancel(Mobile from)
+            {
+            }
+        }
+
+        public DoomPlaque(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            CheckList();
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            reader.ReadInt(); // version
+        }
+    }
+}

Scripts/Services/Seasonal Events/TreasuresOfDoom/Items/DoomSign.cs

@@ -0,0 +1,134 @@
+using System;
+using System.Collections.Generic;
+
+using Server;
+using Server.Mobiles;
+using Server.Gumps;
+using Server.Network;
+using Server.Engines.Points;
+
+namespace Server.Items
+{
+    public class DoomSign : Item, IRevealableItem
+    {
+        public List<Mobile> Revealed { get; set; }
+        public Dictionary<Mobile, DateTime> NextMessage { get; set; }
+
+        public override bool ForceShowProperties { get { return true; } }
+        public bool CheckWhenHidden { get { return false; } }
+
+        [Constructable]
+        public DoomSign()
+            : base(0xBD0)
+        {
+            Movable = false;
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (PointsSystem.TreasuresOfDoom.InSeason && m.InRange(GetWorldLocation(), 2))
+            {
+                var gump = new Gump(150, 150);
+
+                gump.AddImage(0, 0, HasRevealed(m) ? 0x7779 : 0x7724);
+
+                m.SendGump(gump);
+            }
+        }
+
+        public override bool HandlesOnMovement { get { return PointsSystem.TreasuresOfDoom.InSeason; } }
+
+        public override void OnMovement(Mobile m, Point3D oldLocation)
+        {
+            if (m.Player && m.InRange(Location, 3) && m.InLOS(this))
+            {
+                if (NextMessage == null)
+                {
+                    NextMessage = new Dictionary<Mobile, DateTime>();
+                }
+                else
+                {
+                    CheckList();
+                }
+
+                if (!NextMessage.ContainsKey(m))
+                {
+                    m.PrivateOverheadMessage(MessageType.Regular, 0x3B2, 1155659, m.NetState); // *The wooden sign seems in oddly good condition for how old the sarcophagus is. Most of the inscription is worn away...*
+
+                    NextMessage[m] = DateTime.UtcNow + TimeSpan.FromMinutes(10);
+                }
+            }
+        }
+
+        private bool HasRevealed(Mobile m)
+        {
+            return Revealed != null && Revealed.Contains(m);
+        }
+
+        public bool CheckReveal(Mobile m)
+        {
+            return Utility.Random((int)m.Skills[SkillName.DetectHidden].Value) < 100;
+        }
+
+        public void OnRevealed(Mobile m)
+        {
+            if (Revealed == null)
+            {
+                Revealed = new List<Mobile>();
+            }
+
+            if (!Revealed.Contains(m))
+            {
+                Revealed.Add(m);
+
+                m.PrivateOverheadMessage(MessageType.Regular, 0x3B2, 1155658, m.NetState); // *You reveal something hidden about the object...*
+            }
+
+            OnDoubleClick(m);
+        }
+
+        public bool CheckPassiveDetect(Mobile m)
+        {
+            return false;
+        }
+
+        private void CheckList()
+        {
+            if (NextMessage == null)
+            {
+                return;
+            }
+
+            var list = new List<Mobile>(NextMessage.Keys);
+
+            foreach (var m in list)
+            {
+                if (NextMessage[m] < DateTime.UtcNow)
+                {
+                    NextMessage.Remove(m);
+                }
+            }
+
+            ColUtility.Free(list);
+        }
+
+        public DoomSign(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            CheckList();
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            reader.ReadInt(); // version
+        }
+    }
+}

Scripts/Services/Seasonal Events/TreasuresOfDoom/Items/LanternOfLight.cs

@@ -0,0 +1,44 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class LanternOfLight : Lantern
+    {
+        private string _OwnerName;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public string OwnerName { get { return _OwnerName; } set { _OwnerName = value; InvalidateProperties(); } }
+
+        [Constructable]
+        public LanternOfLight()
+        {
+        }
+
+        public override void AddNameProperty(ObjectPropertyList list)
+        {
+            list.Add(1155597, _OwnerName); // ~1_NAME~'s Lantern of Light
+        }
+
+        public LanternOfLight(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write(_OwnerName);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            reader.ReadInt(); // version
+
+            _OwnerName = reader.ReadString();
+        }
+    }
+}

Scripts/Services/Seasonal Events/TreasuresOfDoom/Items/PropheticManuscript.cs

@@ -0,0 +1,54 @@
+using Server;
+
+namespace Server.Items
+{
+    public class PropheticManuscript : BaseJournal
+    {
+        public override int LabelNumber { get { return 1155631; } } // Prophetic Manuscript
+
+        public int Index { get; set; }
+
+        public override TextDefinition Title { get { return 1155638 + Index; } }
+        public override TextDefinition Body { get { return 1155632 + Index; } }
+
+        [Constructable]
+        public PropheticManuscript()
+            : this(Utility.RandomMinMax(0, 4))
+        {
+        }
+
+        public PropheticManuscript(int index)
+        {
+            ItemID = 0x42BF;
+            Index = index;
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            list.Add(1154760, "#1155637"); // By: Owain the Blind Prophet
+        }
+
+        public PropheticManuscript(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write(Index);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            Index = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Seasonal Events/TreasuresOfDoom/Items/RewardTitleDeed.cs

@@ -0,0 +1,37 @@
+using Server;
+
+namespace Server.Items
+{
+    public class TreasuresOfDoomRewardDeed : BaseRewardTitleDeed
+    {
+        private TextDefinition _Title;
+
+        public override TextDefinition Title { get { return _Title; } }
+
+        public TreasuresOfDoomRewardDeed(int localization)
+        {
+            _Title = localization;
+        }
+
+        public TreasuresOfDoomRewardDeed(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            TextDefinition.Serialize(writer, _Title);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            _Title = TextDefinition.Deserialize(reader);
+        }
+    }
+}

Scripts/Services/Seasonal Events/TreasuresOfDoom/Items/ScepterOfPride.cs

@@ -0,0 +1,43 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class ScepterOfPride : Scepter
+    {
+        public override bool IsArtifact { get { return true; } }
+        public override int LabelNumber { get { return 1155623; } } // Sceptre of Pride
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        [Constructable]
+        public ScepterOfPride()
+        {
+            WeaponAttributes.HitLeechStam = 70;
+            WeaponAttributes.HitLeechMana = 70;
+            WeaponAttributes.HitLeechHits = 70;
+            Attributes.WeaponSpeed = 30;
+
+            Slayer = SlayerName.Exorcism;
+            Slayer2 = SlayerName.Silver;
+        }
+
+        public ScepterOfPride(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            reader.ReadInt(); // version
+        }
+    }
+}

Scripts/Services/Seasonal Events/TreasuresOfDoom/Items/TinctureOfSilver.cs

@@ -0,0 +1,87 @@
+using System;
+
+using Server;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class TinctureOfSilver : Item
+    {
+        public override int LabelNumber { get { return 1155619; } } // Tincture of Silver
+
+        [Constructable]
+        public TinctureOfSilver()
+            : base(0x183B)
+        {
+            Hue = 1900;
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (IsChildOf(m.Backpack))
+            {
+                m.SendLocalizedMessage(1155613); // Target the weapon, spellbook, or instrument you wish to apply this to...
+                m.BeginTarget(-1, false, Server.Targeting.TargetFlags.None, (from, targeted) =>
+                {
+                    if (targeted is Item && targeted is ISlayer)
+                    {
+                        var item = (Item)targeted;
+                        var slayer = (ISlayer)targeted;
+
+                        var socket = item.GetSocket<SlayerSocket>();
+
+                        if (socket == null || socket.Slayer != SlayerName.Silver)
+                        {
+                            if (slayer.Slayer != SlayerName.None && slayer.Slayer2 != SlayerName.None)
+                            {
+                                from.SendLocalizedMessage(1155680); // You cannot apply Tincture of Silver to items that are already slayers!
+                            }
+                            else
+                            {
+                                item.AttachSocket(new SlayerSocket(SlayerName.Silver, TimeSpan.FromHours(1)));
+
+                                Delete();
+
+                                from.SendLocalizedMessage(1155616); // You carefully apply Tincture of Silver to the item.  The effects will fade in one hour.
+                            }
+                        }
+                        else
+                        {
+                            from.SendLocalizedMessage(1155614); // This item is already treated with Tincture of Silver!
+                        }
+                    }
+                    else
+                    {
+                        from.SendLocalizedMessage(1155615); // You cannot apply Tincture of Silver to this item.
+                    }
+                });
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            list.Add(1155620); // When Applied:
+            list.Add(1155621, "#1155622"); // 200% Damage Increase towards Monsters of ~1_NAME~ : Undead Vulnerability
+        }
+
+        public TinctureOfSilver(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            reader.ReadInt(); // version
+        }
+    }
+}