Overwrite

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

Scripts/Services/Revamped Dungeons/BlackthornDungeon/InvasionSpawner/Creatures.cs

@@ -0,0 +1,615 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using System.Linq;
+using Server.Mobiles;
+using Server.Items;
+using Server.Spells;
+using Server.Spells.Necromancy;
+using Server.Engines.CityLoyalty;
+
+namespace Server.Engines.Blackthorn
+{
+    public class Invader : BaseCreature
+    {
+        public static SkillName RandomSpecialty()
+        {
+            return _Specialties[Utility.Random(_Specialties.Length)];
+        }
+
+        private static SkillName[] _Specialties =
+        {
+            SkillName.Swords,
+            SkillName.Fencing,
+            SkillName.Macing,
+            SkillName.Archery,
+            SkillName.Magery,
+            SkillName.Mysticism,
+            SkillName.Spellweaving,
+            SkillName.Bushido,
+            SkillName.Bushido,
+            SkillName.Ninjitsu,
+            SkillName.Chivalry,
+            SkillName.Necromancy,
+            SkillName.Poisoning
+        };
+
+        private InvasionType _InvasionType;
+        private SkillName _Specialty;
+
+        private bool _Sampire;
+        private DateTime _NextSpecial;
+
+        public override bool AlwaysMurderer { get { return true; } }
+        public override double HealChance { get { return AI == AIType.AI_Melee || AI == AIType.AI_Paladin ? 1.0 : 0.0; } }
+        public override double WeaponAbilityChance { get { return AI == AIType.AI_Melee || AI == AIType.AI_Paladin ? 0.4 : 0.1; } }
+        public override bool CanStealth { get { return _Specialty == SkillName.Ninjitsu; } }
+
+        public override WeaponAbility GetWeaponAbility()
+        {
+            BaseWeapon wep = Weapon as BaseWeapon;
+
+            if (wep != null)
+            {
+                return 0.6 > Utility.RandomDouble() ? wep.PrimaryAbility : wep.SecondaryAbility;
+            }
+
+            return null;
+        }
+
+        public override bool UseSmartAI { get { return true; } }
+        public virtual bool CanDoSpecial { get { return SpellCaster; } }
+
+        public virtual double MinSkill { get { return 100.0; } }
+        public virtual double MaxSkill { get { return 120.0; } }
+        public virtual int MinResist { get { return 10; } }
+        public virtual int MaxResist { get { return 20; } }
+
+        public bool SpellCaster { get { return AI != AIType.AI_Melee && AI != AIType.AI_Ninja && AI != AIType.AI_Samurai && AI != AIType.AI_Paladin; } }
+
+        [Constructable]
+        public Invader(InvasionType type)
+            : this(RandomSpecialty(), type)
+        {
+        }
+
+        [Constructable]
+        public Invader(SkillName specialty, InvasionType type)
+            : base(GetAI(specialty), FightMode.Closest, 10, 1, .2, .1)
+        {
+            _Specialty = specialty;
+            _InvasionType = type;
+
+            if (_Specialty == SkillName.Bushido && Utility.RandomBool())
+                _Sampire = true;
+
+            if (Female = Utility.RandomBool())
+            {
+                //Body = 0x191;
+                Name = NameList.RandomName("female");
+            }
+            else
+            {
+                //Body = 0x190;
+                Name = NameList.RandomName("male");
+            }
+
+            SetBody();
+
+            string title;
+
+            if (_Sampire)
+            {
+                title = "the sampire";
+            }
+            else if (specialty == SkillName.Magery)
+            {
+                title = "the wizard";
+            }
+            else
+            {
+                title = String.Format("the {0}", Skills[specialty].Info.Title);
+                if (Female && title.EndsWith("man"))
+                    title = title.Substring(0, title.Length - 3) + "woman";
+            }
+
+            Title = title;
+
+            SetStr(120, 170);
+            SetDex(SpellCaster ? 75 : 150);
+            SetInt(SpellCaster ? 1800 : 500);
+
+            SetHits(800, 1250);
+
+            if (AI == AIType.AI_Melee)
+                SetDamage(15, 28);
+            else if (!SpellCaster)
+                SetDamage(12, 22);
+            else
+                SetDamage(8, 18);
+
+            Fame = 8000;
+            Karma = -8000;  
+
+            SetResists();
+            SetSkills();
+            EquipSpecialty();
+
+            _NextSpecial = DateTime.UtcNow;
+
+            if (_Sampire)
+            {
+                Timer.DelayCall(TimeSpan.FromSeconds(1), () =>
+                    {
+                        VampiricEmbraceSpell spell = new VampiricEmbraceSpell(this, null);
+                        spell.Cast();
+                    });
+            }
+
+            SetAreaEffect(AreaEffect.AuraOfEnergy);
+        }
+
+        public virtual void SetBody()
+        {
+            switch (_Specialty)
+            {
+                default:
+                    if (0.75 > Utility.RandomDouble())
+                        Race = Race.Human;
+                    else
+                        Race = Race.Elf; break;
+                case SkillName.Archery:
+                case SkillName.Spellweaving: Race = Race.Elf; break;
+            }
+
+            HairItemID = Race.RandomHair(Female);
+            HairHue = Race.RandomHairHue();
+
+            FacialHairItemID = Race.RandomFacialHair(Female);
+            FacialHairHue = Race.RandomHairHue();
+
+            Hue = Race.RandomSkinHue();
+        }
+
+        public virtual void SetResists()
+        {
+            SetResistance(ResistanceType.Physical, MinResist, MaxResist);
+            SetResistance(ResistanceType.Fire, MinResist, MaxResist);
+            SetResistance(ResistanceType.Cold, MinResist, MaxResist);
+            SetResistance(ResistanceType.Poison, MinResist, MaxResist);
+            SetResistance(ResistanceType.Energy, MinResist, MaxResist);
+        }
+
+        public virtual void SetSkills()
+        {
+            SetSkill(SkillName.Fencing, MinSkill, MaxSkill);
+            SetSkill(SkillName.Macing, MinSkill, MaxSkill);
+            SetSkill(SkillName.MagicResist, MinSkill, MaxSkill);
+            SetSkill(SkillName.Swords, MinSkill, MaxSkill);
+            SetSkill(SkillName.Tactics, MinSkill, MaxSkill);
+            SetSkill(SkillName.Wrestling, MinSkill, MaxSkill);
+            SetSkill(SkillName.Archery, MinSkill, MaxSkill);
+            SetSkill(SkillName.Parry, MinSkill, MaxSkill);
+
+            if (SpellCaster)
+            {
+                SetSkill(SkillName.Magery, MinSkill, MaxSkill);
+                SetSkill(SkillName.EvalInt, MinSkill, MaxSkill);
+            }
+
+            if (Skills[_Specialty].Base < MinSkill)
+                SetSkill(_Specialty, MinSkill, MaxSkill);
+
+            if (_Sampire)
+            {
+                SetSkill(SkillName.Necromancy, MinSkill, MaxSkill);
+            }
+
+            if (_Sampire || _Specialty == SkillName.Necromancy)
+            {
+                SetSkill(SkillName.SpiritSpeak, MinSkill, MaxSkill);
+            }
+
+            if (_Specialty == SkillName.Ninjitsu)
+            {
+                SetSkill(SkillName.Hiding, 100);
+                SetSkill(SkillName.Stealth, 100);
+            }
+        }
+
+        public virtual void EquipSpecialty()
+        {
+            if (AbilityProfile != null && AbilityProfile.HasAbility(SpecialAbility.Heal))
+                PackItem(new Bandage(Utility.RandomMinMax(10, 25)));
+
+            SetWearable(new ThighBoots());
+            SetWearable(new BodySash(), Utility.RandomSlimeHue());
+
+            switch (_Specialty)
+            {
+                case SkillName.Chivalry:
+                    SetWearable(RandomSwordWeapon());
+                    PaladinEquip();
+                    break;
+                case SkillName.Swords:
+                    SetWearable(RandomSwordWeapon());
+                    StandardMeleeEquip();
+                    break;
+                case SkillName.Fencing:
+                    SetWearable(RandomFencingWeapon());
+                    StandardMeleeEquip();
+                    break;
+                case SkillName.Macing:
+                    SetWearable(RandomMaceWeapon());
+                    StandardMeleeEquip();
+                    break;
+                case SkillName.Archery:
+                    SetWearable(RandomArhceryWeapon());
+                    StandardMeleeEquip();
+                    break;
+                case SkillName.Magery:
+                    SetWearable(RandomMageWeapon());
+                    StandardMageEquip();
+                    break;
+                case SkillName.Mysticism:
+                    SetWearable(RandomMageWeapon());
+                    StandardMageEquip();
+                    break;
+                case SkillName.Spellweaving:
+                    SetWearable(RandomMageWeapon());
+                    StandardMageEquip();
+                    break;
+                case SkillName.Necromancy:
+                    SetWearable(RandomMageWeapon());
+                    StandardMageEquip();
+                    break;
+                case SkillName.Bushido:
+                    BaseWeapon w = RandomSamuraiWeapon() as BaseWeapon;
+                    SetWearable(w);
+
+                    SetWearable(new LeatherSuneate());
+                    SetWearable(new LeatherJingasa());
+                    SetWearable(new LeatherDo());
+                    SetWearable(new LeatherHiroSode());
+                    SetWearable(new SamuraiTabi(Utility.RandomNondyedHue()));
+
+                    if (_Sampire)
+                        w.WeaponAttributes.HitLeechHits = 100;
+
+                    SetSkill(SkillName.Parry, 120);
+                    break;
+                case SkillName.Ninjitsu:
+                    SetWearable(RandomNinjaWeapon());
+
+                    LeatherNinjaBelt belt = new LeatherNinjaBelt();
+                    belt.UsesRemaining = 20;
+                    belt.Poison = Poison.Greater;
+                    belt.PoisonCharges = 20;
+                    SetWearable(belt);
+
+                    for (int i = 0; i < 2; i++)
+                    {
+                        Fukiya f = new Fukiya();
+                        f.UsesRemaining = 10;
+                        f.Poison = Poison.Greater;
+                        f.PoisonCharges = 10;
+                        f.Movable = false;
+                        PackItem(f);
+                    }
+
+                    SetWearable(new NinjaTabi());
+                    SetWearable(new LeatherNinjaJacket());
+                    SetWearable(new LeatherNinjaHood());
+                    SetWearable(new LeatherNinjaPants());
+                    SetWearable(new LeatherNinjaMitts());
+
+                    break;
+                case SkillName.Poisoning:
+                    BaseWeapon wep = RandomAssassinWeapon() as BaseWeapon;
+                    wep.Poison = Poison.Lethal;
+                    wep.PoisonCharges = 100;
+                    SetWearable(wep);
+
+                    SetWearable(new LeatherChest());
+                    SetWearable(new LeatherLegs());
+                    SetWearable(new LeatherGloves());
+                    SetWearable(new LeatherGorget());
+                    break;
+            }
+        }
+
+        private void PaladinEquip()
+        {
+            SetWearable(Loot.Construct(new Type[] { typeof(Bascinet), typeof(Helmet), typeof(PlateHelm) }), 1153);
+
+            SetWearable(new PlateChest());
+            SetWearable(new PlateLegs());
+            SetWearable(new PlateGloves());
+            SetWearable(new PlateGorget());
+            SetWearable(new PlateArms());
+            SetWearable(new MetalKiteShield());
+
+            SetSkill(SkillName.Parry, 120);
+        }
+
+        private void StandardMeleeEquip()
+        {
+            SetWearable(Loot.Construct(new Type[] { typeof(Bascinet), typeof(Helmet), typeof(LeatherCap), typeof(RoyalCirclet) }));
+
+            SetWearable(new ChainChest());
+            SetWearable(new ChainLegs());
+            SetWearable(new RingmailGloves());
+            SetWearable(new LeatherGorget());
+        }
+
+        private void StandardMageEquip()
+        {
+            bool mage = AI == AIType.AI_Mage;
+
+            SetWearable(new WizardsHat(), mage ? Utility.RandomBlueHue() : Utility.RandomRedHue());
+            SetWearable(new Robe(), mage ? Utility.RandomBlueHue() : Utility.RandomRedHue());
+            SetWearable(new LeatherGloves());
+        }
+
+        public static AIType GetAI(SkillName skill)
+        {
+            switch (skill)
+            {
+                default: return AIType.AI_Melee;
+                case SkillName.Ninjitsu: return AIType.AI_Ninja;
+                case SkillName.Bushido: return AIType.AI_Samurai;
+                case SkillName.Chivalry: return AIType.AI_Paladin;
+                case SkillName.Magery: return AIType.AI_Mage;
+                case SkillName.Necromancy: return AIType.AI_NecroMage;
+                case SkillName.Spellweaving: return AIType.AI_Spellweaving;
+                case SkillName.Mysticism: return AIType.AI_Mystic;
+            }
+        }
+
+        public Item RandomSwordWeapon()
+        {
+            if (Race == Race.Elf)
+                return Loot.Construct(new Type[] { typeof(ElvenMachete), typeof(RadiantScimitar) });
+
+            return Loot.Construct(new Type[] { typeof(Broadsword), typeof(Longsword), typeof(Katana), typeof(Halberd), typeof(Bardiche), typeof(VikingSword) });
+        }
+
+        public Item RandomFencingWeapon()
+        {
+            if(Race == Race.Elf)
+                return Loot.Construct(new Type[] { typeof(Leafblade), typeof(WarCleaver), typeof(AssassinSpike) });
+
+            return Loot.Construct(new Type[] { typeof(Kryss), typeof(Spear), typeof(ShortSpear), typeof(Lance), typeof(Pike) });
+        }
+
+        public Item RandomMaceWeapon()
+        {
+            return Loot.Construct(new Type[] { typeof(Mace), typeof(WarHammer), typeof(WarAxe), typeof(BlackStaff), typeof(QuarterStaff), typeof(WarMace), typeof(DiamondMace), typeof(Scepter)  });
+        }
+
+        public Item RandomArhceryWeapon()
+        {
+            if (Race == Race.Elf)
+                return Loot.Construct(new Type[] { typeof(MagicalShortbow), typeof(ElvenCompositeLongbow) });
+
+            return Loot.Construct(new Type[] { typeof(Bow), typeof(Crossbow), typeof(HeavyCrossbow), typeof(CompositeBow), typeof(RepeatingCrossbow) });
+        }
+
+        public Item RandomMageWeapon()
+        {
+            return Loot.Construct(new Type[] { typeof(Spellbook), typeof(GnarledStaff), typeof(BlackStaff), typeof(QuarterStaff), typeof(WildStaff) });
+        }
+
+        public Item RandomSamuraiWeapon()
+        {
+            return Loot.Construct(new Type[] { typeof(Lajatang), typeof(Wakizashi), typeof(NoDachi) });
+        }
+
+        public Item RandomNinjaWeapon()
+        {
+            return Loot.Construct(new Type[] { typeof(Wakizashi), typeof(Tessen), typeof(Nunchaku), typeof(Daisho), typeof(Sai), typeof(Tekagi), typeof(Kama), typeof(Katana) });
+        }
+
+        public Item RandomAssassinWeapon()
+        {
+            return Loot.Construct(new Type[] { typeof(Cleaver), typeof(ButcherKnife), typeof(Kryss), typeof(Dagger) });
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            list.Add(1154196 + (int)_InvasionType);
+        }
+
+        public override void OnThink()
+        {
+            base.OnThink();
+
+            if (Combatant == null)
+                return;
+
+            if (CanDoSpecial && InRange(Combatant, 4) && 0.1 > Utility.RandomDouble() && _NextSpecial < DateTime.UtcNow)
+            {
+                DoSpecial();
+
+                _NextSpecial = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(30, 60));
+            }
+            else if (_Sampire)
+            {
+                if (0.1 > Utility.RandomDouble() && Weapon is BaseWeapon && !CurseWeaponSpell.IsCursed(this, (BaseWeapon)Weapon))
+                {
+                    CurseWeaponSpell spell = new CurseWeaponSpell(this, null);
+                    spell.Cast();
+                }
+                else if (!TransformationSpellHelper.UnderTransformation(this, typeof(VampiricEmbraceSpell)))
+                {
+                    VampiricEmbraceSpell spell = new VampiricEmbraceSpell(this, null);
+                    spell.Cast();
+                }
+            }
+        }
+
+        private void DoSpecial()
+        {
+            if (this.Map == null || this.Map == Map.Internal)
+                return;
+
+            Map m = this.Map;
+
+            for (int i = 0; i < 4; i++)
+            {
+                Timer.DelayCall(TimeSpan.FromMilliseconds(i * 50), o =>
+                {
+                    Server.Misc.Geometry.Circle2D(this.Location, m, (int)o, (pnt, map) =>
+                    {
+                        Effects.SendLocationEffect(pnt, map, Utility.RandomBool() ? 14000 : 14013, 14, 20, 2018, 0);
+                    });
+                }, i);
+            }
+
+            Timer.DelayCall(TimeSpan.FromMilliseconds(200), () =>
+                {
+                    if (m != null)
+                    {
+                        List<Mobile> list = new List<Mobile>();
+                        IPooledEnumerable eable = m.GetMobilesInRange(this.Location, 4);
+
+                        foreach (Mobile mob in eable)
+                        {
+                            if (mob.AccessLevel > AccessLevel.Player)
+                                continue;
+
+                            if (mob is PlayerMobile || (mob is BaseCreature && ((BaseCreature)mob).GetMaster() is PlayerMobile) && CanBeHarmful(mob))
+                                list.Add(mob);
+                        }
+
+                        list.ForEach(mob =>
+                            {
+                                AOS.Damage(mob, this, Utility.RandomMinMax(80, 90), 0, 0, 0, 0, 0, 100, 0);
+                            });
+
+                        list.Clear();
+                        list.TrimExcess();
+                    }
+                });
+        }
+
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public Invader(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write((int)_Specialty);
+            writer.Write((int)_InvasionType);
+            writer.Write(_Sampire);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            _Specialty = (SkillName)reader.ReadInt();
+            _InvasionType = (InvasionType)reader.ReadInt();
+            _Sampire = reader.ReadBool();
+
+            _NextSpecial = DateTime.UtcNow;
+        }
+    }
+
+    public class InvaderCaptain : Invader
+    {
+        public override double MinSkill { get { return 105.0; } }
+        public override double MaxSkill { get { return 130.0; } }
+        public override int MinResist { get { return 20; } }
+        public override int MaxResist { get { return 30; } }
+
+        [Constructable]
+        public InvaderCaptain(InvasionType type) : base(type)
+        {
+            SetStr(250);
+            SetDex(SpellCaster ? 150 : 200);
+            SetInt(SpellCaster ? 1000 : 5000);
+
+            SetHits(8000, 12000);
+
+            if (AI == AIType.AI_Melee)
+                SetDamage(22, 30);
+            else if (!SpellCaster)
+                SetDamage(20, 28);
+            else
+                SetDamage(10, 20);
+
+            Fame = 48000;
+            Karma = -48000;  
+        }
+
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);
+
+            var rights = GetLootingRights();
+            rights.Sort();
+
+            List<Mobile> list = rights.Select(x => x.m_Mobile).Where(m => m.InRange(c.Location, 20)).ToList();
+
+            if(list.Count > 0)
+            {
+                for (int i = 0; i < 2; i++)
+                {
+                    Mobile drop;
+                    Item item = InvasionController.CreateItem(list[0]);
+
+                    if (list.Count == 1 || i >= list.Count)
+                        drop = list[0];
+                    else
+                        drop = list[i];
+
+                    drop.SendLocalizedMessage(1154530); // You notice the crest of Minax on your fallen foe's equipment and decide it may be of some value...
+
+                    if (drop.Backpack == null || !drop.Backpack.TryDropItem(drop, item, false))
+                    {
+                        drop.BankBox.DropItem(item);
+                        drop.SendLocalizedMessage(1079730); // // The item has been placed into your bank box.
+                    }
+                }
+            }
+
+            ColUtility.Free(list);
+        }
+
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.UltraRich, 2);
+            this.AddLoot(LootPack.SuperBoss, 1);
+        }
+
+        public InvaderCaptain(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);
+            int version = reader.ReadInt();
+        }
+    }
+}