Overwrite

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

Scripts/Mobiles/Event/BaneDragon.cs

@@ -0,0 +1,165 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    public class BaneDragon : BaseMount
+    {
+        public static readonly int MaxPower = 10;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int PowerLevel { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int PowerDecay
+        {
+            get { return _PowerDecay; }
+            set
+            {
+                _PowerDecay = value;
+
+                if (_PowerDecay >= 10)
+                {
+                    _PowerDecay = 0;
+                    PowerLevel = Math.Max(1, PowerLevel - 1);
+                }
+            }
+        }
+
+        private DateTime _NextSpecial;
+        private int _PowerDecay;
+
+        [Constructable]
+        public BaneDragon()
+            : base("Bane Dragon", 0x31A, 0x3EBD, AIType.AI_Mage, FightMode.Aggressor, 10, 1, 0.2, 0.4)
+        {
+            BaseSoundID = 0x16A;
+            Hue = 1175;
+
+            SetStr(500, 555);
+            SetDex(85, 125);
+            SetInt(100, 165);
+
+            SetHits(550, 650);
+
+            SetDamage(20, 26);
+
+            SetDamageType(ResistanceType.Physical, 50);
+            SetDamageType(ResistanceType.Cold, 25);
+            SetDamageType(ResistanceType.Poison, 25);
+
+            SetResistance(ResistanceType.Physical, 60, 70);
+            SetResistance(ResistanceType.Fire, 40, 50);
+            SetResistance(ResistanceType.Cold, 30, 45);
+            SetResistance(ResistanceType.Poison, 50, 60);
+            SetResistance(ResistanceType.Energy, 20, 40);
+
+            SetSkill(SkillName.Anatomy, 10.0);
+            SetSkill(SkillName.MagicResist, 85.0);
+            SetSkill(SkillName.Tactics, 110.0);
+            SetSkill(SkillName.Wrestling, 90.0);
+            SetSkill(SkillName.Magery, 45.0);
+            SetSkill(SkillName.EvalInt, 35.0);
+            SetSkill(SkillName.Meditation, 35.0);
+
+            Fame = 18000;
+            Karma = -18000;
+
+            Tamable = true;
+            ControlSlots = 3;
+            MinTameSkill = 107.1;
+
+            PowerLevel = 10;
+            _NextSpecial = DateTime.UtcNow;
+        }
+
+        public override Poison HitPoison { get { return Poison.Lethal; } }
+        public override bool AlwaysMurderer { get { return true; } }
+        public override FoodType FavoriteFood { get { return FoodType.BlackrockStew; } }
+
+        public override bool CheckFeed(Mobile from, Item dropped)
+        {
+            if (dropped is BowlOfBlackrockStew)
+            {
+                if (PowerLevel >= MaxPower)
+                {
+                    from.SendLocalizedMessage(1115755); // The creature looks at you strangely and shakes its head no.
+                }
+                else
+                {
+                    PowerLevel++;
+
+                    if (PowerLevel >= MaxPower)
+                    {
+                        from.SendLocalizedMessage(1115753); // Your bane dragon is returned to maximum power by this stew.
+                    }
+                    else
+                    {
+                        from.SendLocalizedMessage(1115754); // Your bane dragon seems a bit peckish today and is not at full power.
+                    }
+
+                    return base.CheckFeed(from, dropped);
+                }
+            }
+
+            return false;
+        }
+
+        public override void OnHarmfulSpell(Mobile from)
+        {
+            if (_NextSpecial < DateTime.UtcNow)
+            {
+                DoSpecial(from);
+
+                _NextSpecial = DateTime.UtcNow + TimeSpan.FromSeconds((double)Utility.RandomMinMax(15, 30) * (double)(11.0 - PowerLevel));
+            }
+        }
+
+        public void DoSpecial(Mobile from)
+        {
+            if (Controlled)
+            {
+                PowerDecay++;
+            }
+
+            MovingParticles(from, 0x36D4, 7, 0, false, true, 1163, 0, 9502, 4019, 0x160, 0);
+            PlaySound(0x15E);
+
+            Timer.DelayCall(TimeSpan.FromSeconds(1), m =>
+                {
+                    AOS.Damage(m, this, Utility.RandomMinMax(8 * PowerLevel, 10 * PowerLevel), 0, 50, 0, 50, 0);
+                    m.ApplyPoison(this, GetHitPoison());
+                }, from);
+        }
+
+        public BaneDragon(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1); // version
+            writer.Write(PowerLevel);
+            writer.Write(PowerDecay);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch (version)
+            {
+                case 1:
+                    PowerLevel = reader.ReadInt();
+                    PowerDecay = reader.ReadInt();
+                    break;
+                case 0: break;
+            }
+        }
+    }
+}

Scripts/Mobiles/Event/PumpkinHead.cs

@@ -0,0 +1,164 @@
+using System;
+using Server.Items;
+using Server.Items.Holiday;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a killer pumpkin corpse")]
+    public class PumpkinHead : BaseCreature
+    {
+        [Constructable]
+        public PumpkinHead()
+            : base(Utility.RandomBool() ? AIType.AI_Melee : AIType.AI_Mage, FightMode.Closest, 10, 1, 0.05, 0.1)
+        {
+            Name = "a killer pumpkin";
+            Body = 1246 + Utility.Random(2);
+
+            BaseSoundID = 268;
+
+            SetStr(350);
+            SetDex(125);
+            SetInt(250);
+
+            SetHits(500);
+            SetMana(1000);
+
+            SetDamage(10, 15);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 55);
+            SetResistance(ResistanceType.Fire, 50);
+            SetResistance(ResistanceType.Cold, 50);
+            SetResistance(ResistanceType.Poison, 65);
+            SetResistance(ResistanceType.Energy, 80);
+
+            SetSkill(SkillName.DetectHidden, 100.0);
+            SetSkill(SkillName.Meditation, 120.0);
+            SetSkill(SkillName.Necromancy, 100.0);
+            SetSkill(SkillName.SpiritSpeak, 120.0);
+            SetSkill(SkillName.Magery, 160.0);
+            SetSkill(SkillName.EvalInt, 100.0);
+            SetSkill(SkillName.MagicResist, 100.0);
+            SetSkill(SkillName.Tactics, 100.0);
+            SetSkill(SkillName.Wrestling, 80.0);
+
+            Fame = 5000;
+            Karma = -5000;
+
+            VirtualArmor = 49;
+        }
+
+        public PumpkinHead(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool AutoDispel { get { return true; } }
+        public override bool BardImmune { get { return true; } }
+        public override bool Unprovokable { get { return true; } }
+        public override bool AreaPeaceImmune { get { return true; } }
+
+        public override void GenerateLoot()
+        {
+            if (Utility.RandomDouble() < .05)
+            {
+                if (Core.TOL)
+                {
+                    switch (Utility.Random(5))
+                    {
+                        case 0:
+                            PackItem(new ObsidianSkull());
+                            break;
+                        case 1:
+                            PackItem(new CrystalSkull());
+                            break;
+                        case 2:
+                            PackItem(new JadeSkull());
+                            break;
+                        case 3:
+                            PackItem(new CarvablePumpkinTall());
+                            break;
+                        case 4:
+                            PackItem(new CarvableGordPumpkinTall());
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                else
+                {
+                    switch (Utility.Random(5))
+                    {
+                        case 0:
+                            PackItem(new PaintedEvilClownMask());
+                            break;
+                        case 1:
+                            PackItem(new PaintedDaemonMask());
+                            break;
+                        case 2:
+                            PackItem(new PaintedPlagueMask());
+                            break;
+                        case 3:
+                            PackItem(new PaintedEvilJesterMask());
+                            break;
+                        case 4:
+                            PackItem(new PaintedPorcelainMask());
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            PackItem(new WrappedCandy());
+            AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public virtual void Lifted_Callback(Mobile from)
+        {
+            if (from != null && !from.Deleted && from is PlayerMobile)
+            {
+                Combatant = from;
+
+                Warmode = true;
+            }
+        }
+
+        public override Item NewHarmfulItem()
+        {
+            Item bad = new AcidSlime(TimeSpan.FromSeconds(10), 25, 30);
+
+            bad.Name = "gooey nasty pumpkin hummus";
+
+            bad.Hue = 144;
+
+            return bad;
+        }
+
+        public override void OnDamage(int amount, Mobile from, bool willKill)
+        {
+            if (Utility.RandomBool())
+            {
+                if (from != null && from.Map != null && Map != Map.Internal && Map == from.Map && from.InRange(this, 12))
+                {
+                    SpillAcid((willKill) ? this : from, (willKill) ? 3 : 1);
+                }
+            }
+
+            base.OnDamage(amount, from, willKill);
+        }
+
+        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/Mobiles/Event/Wanderer.cs

@@ -0,0 +1,68 @@
+using System;
+
+namespace Server.Mobiles
+{
+    public class Wanderer : Mobile
+    {
+        private readonly Timer m_Timer;
+        [Constructable]
+        public Wanderer()
+        {
+            this.Name = "Me";
+            this.Body = 0x1;
+            this.AccessLevel = AccessLevel.Counselor;
+
+            this.m_Timer = new InternalTimer(this);
+            this.m_Timer.Start();
+        }
+
+        public Wanderer(Serial serial)
+            : base(serial)
+        {
+            this.m_Timer = new InternalTimer(this);
+            this.m_Timer.Start();
+        }
+
+        public override void OnDelete()
+        {
+            this.m_Timer.Stop();
+
+            base.OnDelete();
+        }
+
+        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();
+        }
+
+        private class InternalTimer : Timer
+        {
+            private readonly Wanderer m_Owner;
+            private int m_Count = 0;
+            public InternalTimer(Wanderer owner)
+                : base(TimeSpan.FromSeconds(0.1), TimeSpan.FromSeconds(0.1))
+            {
+                this.m_Owner = owner;
+            }
+
+            protected override void OnTick()
+            {
+                if ((this.m_Count++ & 0x3) == 0)
+                {
+                    this.m_Owner.Direction = (Direction)(Utility.Random(8) | 0x80);
+                }
+
+                this.m_Owner.Move(this.m_Owner.Direction);
+            }
+        }
+    }
+}