Reorganizes Project (#41)

Projects/Scripts/Mobiles/Monsters/AOS/AbysmalHorror.cs

@@ -0,0 +1,92 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class AbysmalHorror : BaseCreature
+  {
+    [Constructible]
+    public AbysmalHorror() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 312;
+      BaseSoundID = 0x451;
+
+      SetStr(401, 420);
+      SetDex(81, 90);
+      SetInt(401, 420);
+
+      SetHits(6000);
+
+      SetDamage(13, 17);
+
+      SetDamageType(ResistanceType.Physical, 50);
+      SetDamageType(ResistanceType.Poison, 50);
+
+      SetResistance(ResistanceType.Physical, 30, 35);
+      SetResistance(ResistanceType.Fire, 100);
+      SetResistance(ResistanceType.Cold, 50, 55);
+      SetResistance(ResistanceType.Poison, 60, 65);
+      SetResistance(ResistanceType.Energy, 77, 80);
+
+      SetSkill(SkillName.EvalInt, 200.0);
+      SetSkill(SkillName.Magery, 112.6, 117.5);
+      SetSkill(SkillName.Meditation, 200.0);
+      SetSkill(SkillName.MagicResist, 117.6, 120.0);
+      SetSkill(SkillName.Tactics, 100.0);
+      SetSkill(SkillName.Wrestling, 84.1, 88.0);
+
+      Fame = 26000;
+      Karma = -26000;
+
+      VirtualArmor = 54;
+    }
+
+    public AbysmalHorror(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an abysmal horror corpse";
+
+    public override bool IgnoreYoungProtection => Core.ML;
+
+    public override string DefaultName => "an abysmal horror";
+
+    public override bool BardImmune => !Core.SE;
+    public override bool Unprovokable => Core.SE;
+    public override bool AreaPeaceImmune => Core.SE;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override int TreasureMapLevel => 1;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return Utility.RandomBool() ? WeaponAbility.MortalStrike : WeaponAbility.WhirlwindAttack;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.UltraRich, 2);
+    }
+
+    public override void OnDeath(Container c)
+    {
+      base.OnDeath(c);
+
+      if (!Summoned && !NoKillAwards && DemonKnight.CheckArtifactChance(this))
+        DemonKnight.DistributeArtifact(this);
+    }
+
+    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();
+
+      if (BaseSoundID == 357)
+        BaseSoundID = 0x451;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/BoneDemon.cs

@@ -0,0 +1,72 @@
+namespace Server.Mobiles
+{
+  public class BoneDemon : BaseCreature
+  {
+    [Constructible]
+    public BoneDemon() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 308;
+      BaseSoundID = 0x48D;
+
+      SetStr(1000);
+      SetDex(151, 175);
+      SetInt(171, 220);
+
+      SetHits(3600);
+
+      SetDamage(34, 36);
+
+      SetDamageType(ResistanceType.Physical, 50);
+      SetDamageType(ResistanceType.Cold, 50);
+
+      SetResistance(ResistanceType.Physical, 75);
+      SetResistance(ResistanceType.Fire, 60);
+      SetResistance(ResistanceType.Cold, 90);
+      SetResistance(ResistanceType.Poison, 100);
+      SetResistance(ResistanceType.Energy, 60);
+
+      SetSkill(SkillName.DetectHidden, 80.0);
+      SetSkill(SkillName.EvalInt, 77.6, 87.5);
+      SetSkill(SkillName.Magery, 77.6, 87.5);
+      SetSkill(SkillName.Meditation, 100.0);
+      SetSkill(SkillName.MagicResist, 50.1, 75.0);
+      SetSkill(SkillName.Tactics, 100.0);
+      SetSkill(SkillName.Wrestling, 100.0);
+
+      Fame = 20000;
+      Karma = -20000;
+
+      VirtualArmor = 44;
+    }
+
+    public BoneDemon(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a bone demon corpse";
+    public override string DefaultName => "a bone demon";
+
+    public override bool BardImmune => !Core.SE;
+    public override bool Unprovokable => Core.SE;
+    public override bool AreaPeaceImmune => Core.SE;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override int TreasureMapLevel => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich, 8);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/CrystalElemental.cs

@@ -0,0 +1,78 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class CrystalElemental : BaseCreature
+  {
+    [Constructible]
+    public CrystalElemental() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 300;
+      BaseSoundID = 278;
+
+      SetStr(136, 160);
+      SetDex(51, 65);
+      SetInt(86, 110);
+
+      SetHits(150);
+
+      SetDamage(10, 15);
+
+      SetDamageType(ResistanceType.Physical, 80);
+      SetDamageType(ResistanceType.Energy, 20);
+
+      SetResistance(ResistanceType.Physical, 50, 60);
+      SetResistance(ResistanceType.Fire, 40, 50);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 100);
+      SetResistance(ResistanceType.Energy, 55, 70);
+
+      SetSkill(SkillName.EvalInt, 70.1, 75.0);
+      SetSkill(SkillName.Magery, 70.1, 75.0);
+      SetSkill(SkillName.Meditation, 65.1, 75.0);
+      SetSkill(SkillName.MagicResist, 80.1, 90.0);
+      SetSkill(SkillName.Tactics, 75.1, 85.0);
+      SetSkill(SkillName.Wrestling, 65.1, 75.0);
+
+      Fame = 6500;
+      Karma = -6500;
+
+      VirtualArmor = 54;
+    }
+
+    public CrystalElemental(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a crystal elemental corpse";
+
+    public override string DefaultName => "a crystal elemental";
+
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override int TreasureMapLevel => 1;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return WeaponAbility.BleedAttack;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Average);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/DarknightCreeper.cs

@@ -0,0 +1,92 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class DarknightCreeper : BaseCreature
+  {
+    [Constructible]
+    public DarknightCreeper() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("darknight creeper");
+      Body = 313;
+      BaseSoundID = 0xE0;
+
+      SetStr(301, 330);
+      SetDex(101, 110);
+      SetInt(301, 330);
+
+      SetHits(4000);
+
+      SetDamage(22, 26);
+
+      SetDamageType(ResistanceType.Physical, 85);
+      SetDamageType(ResistanceType.Poison, 15);
+
+      SetResistance(ResistanceType.Physical, 60);
+      SetResistance(ResistanceType.Fire, 60);
+      SetResistance(ResistanceType.Cold, 100);
+      SetResistance(ResistanceType.Poison, 90);
+      SetResistance(ResistanceType.Energy, 75);
+
+      SetSkill(SkillName.DetectHidden, 80.0);
+      SetSkill(SkillName.EvalInt, 118.1, 120.0);
+      SetSkill(SkillName.Magery, 112.6, 120.0);
+      SetSkill(SkillName.Meditation, 150.0);
+      SetSkill(SkillName.Poisoning, 120.0);
+      SetSkill(SkillName.MagicResist, 90.1, 90.9);
+      SetSkill(SkillName.Tactics, 100.0);
+      SetSkill(SkillName.Wrestling, 90.1, 90.9);
+      SetSkill(SkillName.Necromancy, 120.1, 130.0);
+      SetSkill(SkillName.SpiritSpeak, 120.1, 130.0);
+
+      Fame = 22000;
+      Karma = -22000;
+
+      VirtualArmor = 34;
+    }
+
+    public DarknightCreeper(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a darknight creeper corpse";
+    public override bool IgnoreYoungProtection => Core.ML;
+
+    public override bool BardImmune => !Core.SE;
+    public override bool Unprovokable => Core.SE;
+    public override bool AreaPeaceImmune => Core.SE;
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override Poison HitPoison => Poison.Lethal;
+
+    public override int TreasureMapLevel => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.UltraRich, 2);
+    }
+
+    public override void OnDeath(Container c)
+    {
+      base.OnDeath(c);
+
+      if (!Summoned && !NoKillAwards && DemonKnight.CheckArtifactChance(this))
+        DemonKnight.DistributeArtifact(this);
+    }
+
+    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();
+
+      if (BaseSoundID == 471)
+        BaseSoundID = 0xE0;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/DemonKnight.cs

@@ -0,0 +1,290 @@
+using System;
+using System.Collections.Generic;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class DemonKnight : BaseCreature
+  {
+    private static bool m_InHere;
+
+    [Constructible]
+    public DemonKnight() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("demon knight");
+      Title = "the Dark Father";
+      Body = 318;
+      BaseSoundID = 0x165;
+
+      SetStr(500);
+      SetDex(100);
+      SetInt(1000);
+
+      SetHits(30000);
+      SetMana(5000);
+
+      SetDamage(17, 21);
+
+      SetDamageType(ResistanceType.Physical, 20);
+      SetDamageType(ResistanceType.Fire, 20);
+      SetDamageType(ResistanceType.Cold, 20);
+      SetDamageType(ResistanceType.Poison, 20);
+      SetDamageType(ResistanceType.Energy, 20);
+
+      SetResistance(ResistanceType.Physical, 30);
+      SetResistance(ResistanceType.Fire, 30);
+      SetResistance(ResistanceType.Cold, 30);
+      SetResistance(ResistanceType.Poison, 30);
+      SetResistance(ResistanceType.Energy, 30);
+
+      SetSkill(SkillName.Necromancy, 120, 120.0);
+      SetSkill(SkillName.SpiritSpeak, 120.0, 120.0);
+
+      SetSkill(SkillName.DetectHidden, 80.0);
+      SetSkill(SkillName.EvalInt, 100.0);
+      SetSkill(SkillName.Magery, 100.0);
+      SetSkill(SkillName.Meditation, 120.0);
+      SetSkill(SkillName.MagicResist, 150.0);
+      SetSkill(SkillName.Tactics, 100.0);
+      SetSkill(SkillName.Wrestling, 120.0);
+
+      Fame = 28000;
+      Karma = -28000;
+
+      VirtualArmor = 64;
+    }
+
+    public DemonKnight(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a demon knight corpse";
+    public override bool IgnoreYoungProtection => Core.ML;
+
+    public static Type[] ArtifactRarity10{ get; } =
+    {
+      typeof(LegacyOfTheDreadLord),
+      typeof(TheTaskmaster)
+    };
+
+    public static Type[] ArtifactRarity11{ get; } =
+    {
+      typeof(TheDragonSlayer),
+      typeof(ArmorOfFortune),
+      typeof(GauntletsOfNobility),
+      typeof(HelmOfInsight),
+      typeof(HolyKnightsBreastplate),
+      typeof(JackalsCollar),
+      typeof(LeggingsOfBane),
+      typeof(MidnightBracers),
+      typeof(OrnateCrownOfTheHarrower),
+      typeof(ShadowDancerLeggings),
+      typeof(TunicOfFire),
+      typeof(VoiceOfTheFallenKing),
+      typeof(BraceletOfHealth),
+      typeof(OrnamentOfTheMagician),
+      typeof(RingOfTheElements),
+      typeof(RingOfTheVile),
+      typeof(Aegis),
+      typeof(ArcaneShield),
+      typeof(AxeOfTheHeavens),
+      typeof(BladeOfInsanity),
+      typeof(BoneCrusher),
+      typeof(BreathOfTheDead),
+      typeof(Frostbringer),
+      typeof(SerpentsFang),
+      typeof(StaffOfTheMagi),
+      typeof(TheBeserkersMaul),
+      typeof(TheDryadBow),
+      typeof(DivineCountenance),
+      typeof(HatOfTheMagi),
+      typeof(HuntersHeaddress),
+      typeof(SpiritOfTheTotem)
+    };
+
+    public override bool BardImmune => !Core.SE;
+    public override bool Unprovokable => Core.SE;
+    public override bool AreaPeaceImmune => Core.SE;
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override int TreasureMapLevel => 1;
+
+    public static Item CreateRandomArtifact()
+    {
+      if (!Core.AOS)
+        return null;
+
+      int count = ArtifactRarity10.Length * 5 + ArtifactRarity11.Length * 4;
+      int random = Utility.Random(count);
+      Type type;
+
+      if (random < ArtifactRarity10.Length * 5)
+      {
+        type = ArtifactRarity10[random / 5];
+      }
+      else
+      {
+        random -= ArtifactRarity10.Length * 5;
+        type = ArtifactRarity11[random / 4];
+      }
+
+      return Loot.Construct(type);
+    }
+
+    public static Mobile FindRandomPlayer(BaseCreature creature)
+    {
+      List<DamageStore> rights = GetLootingRights(creature.DamageEntries, creature.HitsMax);
+
+      for (int i = rights.Count - 1; i >= 0; --i)
+      {
+        DamageStore ds = rights[i];
+
+        if (!ds.m_HasRight)
+          rights.RemoveAt(i);
+      }
+
+      if (rights.Count > 0)
+        return rights[Utility.Random(rights.Count)].m_Mobile;
+
+      return null;
+    }
+
+    public static void DistributeArtifact(BaseCreature creature)
+    {
+      DistributeArtifact(creature, CreateRandomArtifact());
+    }
+
+    public static void DistributeArtifact(BaseCreature creature, Item artifact)
+    {
+      DistributeArtifact(FindRandomPlayer(creature), artifact);
+    }
+
+    public static void DistributeArtifact(Mobile to)
+    {
+      DistributeArtifact(to, CreateRandomArtifact());
+    }
+
+    public static void DistributeArtifact(Mobile to, Item artifact)
+    {
+      if (to == null || artifact == null)
+        return;
+
+      Container pack = to.Backpack;
+
+      if (pack?.TryDropItem(to, artifact, false) != true)
+        to.BankBox.DropItem(artifact);
+
+      to.SendLocalizedMessage(
+        1062317); // For your valor in combating the fallen beast, a special artifact has been bestowed on you.
+    }
+
+    public static int GetArtifactChance(Mobile boss)
+    {
+      if (!Core.AOS)
+        return 0;
+
+      int luck = LootPack.GetLuckChanceForKiller(boss);
+      int chance;
+
+      if (boss is DemonKnight)
+        chance = 1500 + luck / 5;
+      else
+        chance = 750 + luck / 10;
+
+      return chance;
+    }
+
+    public static bool CheckArtifactChance(Mobile boss)
+    {
+      return GetArtifactChance(boss) > Utility.Random(100000);
+    }
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      switch (Utility.Random(3))
+      {
+        default:
+        case 0: return WeaponAbility.DoubleStrike;
+        case 1: return WeaponAbility.WhirlwindAttack;
+        case 2: return WeaponAbility.CrushingBlow;
+      }
+    }
+
+    public override void OnDeath(Container c)
+    {
+      base.OnDeath(c);
+
+      if (!Summoned && !NoKillAwards && CheckArtifactChance(this))
+        DistributeArtifact(this);
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.SuperBoss, 2);
+      AddLoot(LootPack.HighScrolls, Utility.RandomMinMax(6, 60));
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      if (from != null && from != this && !m_InHere)
+      {
+        m_InHere = true;
+        AOS.Damage(from, this, Utility.RandomMinMax(8, 20), 100, 0, 0, 0, 0);
+
+        MovingEffect(from, 0xECA, 10, 0, false, false, 0, 0);
+        PlaySound(0x491);
+
+        if (0.05 > Utility.RandomDouble())
+          Timer.DelayCall(TimeSpan.FromSeconds(1.0), CreateBones_Callback, from);
+
+        m_InHere = false;
+      }
+    }
+
+    public virtual void CreateBones_Callback(Mobile from)
+    {
+      Map map = from.Map;
+
+      if (map == null)
+        return;
+
+      int count = Utility.RandomMinMax(1, 3);
+
+      for (int i = 0; i < count; ++i)
+      {
+        int x = from.X + Utility.RandomMinMax(-1, 1);
+        int y = from.Y + Utility.RandomMinMax(-1, 1);
+        int z = from.Z;
+
+        if (!map.CanFit(x, y, z, 16))
+        {
+          z = map.GetAverageZ(x, y);
+
+          if (z == from.Z || !map.CanFit(x, y, z, 16))
+            continue;
+        }
+
+        UnholyBone bone = new UnholyBone
+        {
+          Hue = 0,
+          Name = "unholy bones",
+          ItemID = Utility.Random(0xECA, 9)
+        };
+
+        bone.MoveToWorld(new Point3D(x, y, z), map);
+      }
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/Devourer.cs

@@ -0,0 +1,72 @@
+namespace Server.Mobiles
+{
+  public class Devourer : BaseCreature
+  {
+    [Constructible]
+    public Devourer() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 303;
+      BaseSoundID = 357;
+
+      SetStr(801, 950);
+      SetDex(126, 175);
+      SetInt(201, 250);
+
+      SetHits(650);
+
+      SetDamage(22, 26);
+
+      SetDamageType(ResistanceType.Physical, 60);
+      SetDamageType(ResistanceType.Cold, 20);
+      SetDamageType(ResistanceType.Energy, 20);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 25, 35);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 60, 70);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.EvalInt, 90.1, 100.0);
+      SetSkill(SkillName.Magery, 90.1, 100.0);
+      SetSkill(SkillName.Meditation, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 90.1, 105.0);
+      SetSkill(SkillName.Tactics, 75.1, 85.0);
+      SetSkill(SkillName.Wrestling, 80.1, 100.0);
+
+      Fame = 9500;
+      Karma = -9500;
+
+      VirtualArmor = 44;
+
+      PackNecroReg(24, 45);
+    }
+
+    public Devourer(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a devourer of souls corpse";
+    public override string DefaultName => "a devourer of souls";
+
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override int Meat => 3;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich, 2);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/FleshGolem.cs

@@ -0,0 +1,72 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class FleshGolem : BaseCreature
+  {
+    [Constructible]
+    public FleshGolem() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 304;
+      BaseSoundID = 684;
+
+      SetStr(176, 200);
+      SetDex(51, 75);
+      SetInt(46, 70);
+
+      SetHits(106, 120);
+
+      SetDamage(18, 22);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 50, 60);
+      SetResistance(ResistanceType.Fire, 25, 35);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 60, 70);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.MagicResist, 50.1, 75.0);
+      SetSkill(SkillName.Tactics, 55.1, 80.0);
+      SetSkill(SkillName.Wrestling, 60.1, 70.0);
+
+      Fame = 1000;
+      Karma = -1800;
+
+      VirtualArmor = 34;
+    }
+
+    public FleshGolem(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a flesh golem corpse";
+
+    public override string DefaultName => "a flesh golem";
+
+    public override bool BleedImmune => true;
+    public override int TreasureMapLevel => 1;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return WeaponAbility.BleedAttack;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/FleshRenderer.cs

@@ -0,0 +1,117 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class FleshRenderer : BaseCreature
+  {
+    [Constructible]
+    public FleshRenderer() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 315;
+
+      SetStr(401, 460);
+      SetDex(201, 210);
+      SetInt(221, 260);
+
+      SetHits(4500);
+
+      SetDamage(16, 20);
+
+      SetDamageType(ResistanceType.Physical, 80);
+      SetDamageType(ResistanceType.Poison, 20);
+
+      SetResistance(ResistanceType.Physical, 80, 90);
+      SetResistance(ResistanceType.Fire, 50, 60);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 100);
+      SetResistance(ResistanceType.Energy, 70, 80);
+
+      SetSkill(SkillName.DetectHidden, 80.0);
+      SetSkill(SkillName.MagicResist, 155.1, 160.0);
+      SetSkill(SkillName.Meditation, 100.0);
+      SetSkill(SkillName.Tactics, 100.0);
+      SetSkill(SkillName.Wrestling, 90.1, 100.0);
+
+      Fame = 23000;
+      Karma = -23000;
+
+      VirtualArmor = 24;
+    }
+
+    public FleshRenderer(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a fleshrenderer corpse";
+
+    public override bool IgnoreYoungProtection => Core.ML;
+
+    public override string DefaultName => "a fleshrenderer";
+
+    public override bool AutoDispel => true;
+    public override bool BardImmune => !Core.SE;
+    public override bool Unprovokable => Core.SE;
+    public override bool AreaPeaceImmune => Core.SE;
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override int TreasureMapLevel => 1;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return Utility.RandomBool() ? WeaponAbility.Dismount : WeaponAbility.ParalyzingBlow;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.UltraRich, 2);
+    }
+
+    public override void OnDeath(Container c)
+    {
+      base.OnDeath(c);
+
+      if (!Summoned && !NoKillAwards && DemonKnight.CheckArtifactChance(this))
+        DemonKnight.DistributeArtifact(this);
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x34C;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x354;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x34C;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x34C;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x354;
+    }
+
+    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();
+
+      if (BaseSoundID == 660)
+        BaseSoundID = -1;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/Gibberling.cs

@@ -0,0 +1,73 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Gibberling : BaseCreature
+  {
+    [Constructible]
+    public Gibberling() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 307;
+      BaseSoundID = 422;
+
+      SetStr(141, 165);
+      SetDex(101, 125);
+      SetInt(56, 80);
+
+      SetHits(85, 99);
+
+      SetDamage(12, 17);
+
+      SetDamageType(ResistanceType.Physical, 0);
+      SetDamageType(ResistanceType.Fire, 40);
+      SetDamageType(ResistanceType.Energy, 60);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 25, 35);
+      SetResistance(ResistanceType.Cold, 25, 35);
+      SetResistance(ResistanceType.Poison, 10, 20);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.MagicResist, 45.1, 70.0);
+      SetSkill(SkillName.Tactics, 67.6, 92.5);
+      SetSkill(SkillName.Wrestling, 60.1, 80.0);
+
+      Fame = 1500;
+      Karma = -1500;
+
+      VirtualArmor = 27;
+    }
+
+    public Gibberling(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a gibberling corpse";
+
+    public override string DefaultName => "a gibberling";
+
+    public override int TreasureMapLevel => 1;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return WeaponAbility.Dismount;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/GoreFiend.cs

@@ -0,0 +1,69 @@
+namespace Server.Mobiles
+{
+  public class GoreFiend : BaseCreature
+  {
+    [Constructible]
+    public GoreFiend() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 305;
+      BaseSoundID = 224;
+
+      SetStr(161, 185);
+      SetDex(41, 65);
+      SetInt(46, 70);
+
+      SetHits(97, 111);
+
+      SetDamage(15, 21);
+
+      SetDamageType(ResistanceType.Physical, 85);
+      SetDamageType(ResistanceType.Poison, 15);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 25, 35);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 5, 15);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.MagicResist, 40.1, 55.0);
+      SetSkill(SkillName.Tactics, 45.1, 70.0);
+      SetSkill(SkillName.Wrestling, 50.1, 70.0);
+
+      Fame = 1500;
+      Karma = -1500;
+
+      VirtualArmor = 24;
+    }
+
+    public GoreFiend(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a gore fiend corpse";
+    public override string DefaultName => "a gore fiend";
+
+    public override bool BleedImmune => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+    }
+
+    public override int GetDeathSound()
+    {
+      return 1218;
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/Impaler.cs

@@ -0,0 +1,93 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Impaler : BaseCreature
+  {
+    [Constructible]
+    public Impaler() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("impaler");
+      Body = 306;
+      BaseSoundID = 0x2A7;
+
+      SetStr(190);
+      SetDex(45);
+      SetInt(190);
+
+      SetHits(5000);
+
+      SetDamage(31, 35);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 90);
+      SetResistance(ResistanceType.Fire, 60);
+      SetResistance(ResistanceType.Cold, 75);
+      SetResistance(ResistanceType.Poison, 60);
+      SetResistance(ResistanceType.Energy, 100);
+
+      SetSkill(SkillName.DetectHidden, 80.0);
+      SetSkill(SkillName.Meditation, 120.0);
+      SetSkill(SkillName.Poisoning, 160.0);
+      SetSkill(SkillName.MagicResist, 100.0);
+      SetSkill(SkillName.Tactics, 100.0);
+      SetSkill(SkillName.Wrestling, 80.0);
+
+      Fame = 24000;
+      Karma = -24000;
+
+      VirtualArmor = 49;
+    }
+
+    public Impaler(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an impaler corpse";
+
+    public override bool IgnoreYoungProtection => Core.ML;
+
+    public override bool AutoDispel => true;
+    public override bool BardImmune => !Core.SE;
+    public override bool Unprovokable => Core.SE;
+    public override bool AreaPeaceImmune => Core.SE;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override Poison HitPoison => 0.8 >= Utility.RandomDouble() ? Poison.Greater : Poison.Deadly;
+
+    public override int TreasureMapLevel => 1;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return Utility.RandomBool() ? WeaponAbility.MortalStrike : WeaponAbility.BleedAttack;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.UltraRich, 2);
+    }
+
+    public override void OnDeath(Container c)
+    {
+      base.OnDeath(c);
+
+      if (!Summoned && !NoKillAwards && DemonKnight.CheckArtifactChance(this))
+        DemonKnight.DistributeArtifact(this);
+    }
+
+    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();
+
+      if (BaseSoundID == 1200)
+        BaseSoundID = 0x2A7;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/MoundOfMaggots.cs

@@ -0,0 +1,63 @@
+namespace Server.Mobiles
+{
+  public class MoundOfMaggots : BaseCreature
+  {
+    [Constructible]
+    public MoundOfMaggots() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 319;
+      BaseSoundID = 898;
+
+      SetStr(61, 70);
+      SetDex(61, 70);
+      SetInt(10);
+
+      SetMana(0);
+
+      SetDamage(3, 9);
+
+      SetDamageType(ResistanceType.Physical, 50);
+      SetDamageType(ResistanceType.Poison, 50);
+
+      SetResistance(ResistanceType.Physical, 90);
+      SetResistance(ResistanceType.Poison, 100);
+
+      SetSkill(SkillName.Tactics, 50.0);
+      SetSkill(SkillName.Wrestling, 50.1, 60.0);
+
+      Fame = 1000;
+      Karma = -1000;
+
+      VirtualArmor = 24;
+    }
+
+    public MoundOfMaggots(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a maggoty corpse";
+    public override string DefaultName => "a mound of maggots";
+
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override int TreasureMapLevel => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+      AddLoot(LootPack.Gems);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/PatchworkSkeleton.cs

@@ -0,0 +1,75 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class PatchworkSkeleton : BaseCreature
+  {
+    [Constructible]
+    public PatchworkSkeleton() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 309;
+      BaseSoundID = 0x48D;
+
+      SetStr(96, 120);
+      SetDex(71, 95);
+      SetInt(16, 40);
+
+      SetHits(58, 72);
+
+      SetDamage(18, 22);
+
+      SetDamageType(ResistanceType.Physical, 85);
+      SetDamageType(ResistanceType.Cold, 15);
+
+      SetResistance(ResistanceType.Physical, 55, 65);
+      SetResistance(ResistanceType.Fire, 50, 60);
+      SetResistance(ResistanceType.Cold, 70, 80);
+      SetResistance(ResistanceType.Poison, 100);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.MagicResist, 70.1, 95.0);
+      SetSkill(SkillName.Tactics, 55.1, 80.0);
+      SetSkill(SkillName.Wrestling, 50.1, 70.0);
+
+      Fame = 500;
+      Karma = -500;
+
+      VirtualArmor = 54;
+    }
+
+    public PatchworkSkeleton(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a patchwork skeletal corpse";
+
+    public override string DefaultName => "a patchwork skeleton";
+
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override int TreasureMapLevel => 1;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return WeaponAbility.Dismount;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/Ravager.cs

@@ -0,0 +1,69 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Ravager : BaseCreature
+  {
+    [Constructible]
+    public Ravager() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 314;
+      BaseSoundID = 357;
+
+      SetStr(251, 275);
+      SetDex(101, 125);
+      SetInt(66, 90);
+
+      SetHits(161, 175);
+
+      SetDamage(15, 20);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 50, 60);
+      SetResistance(ResistanceType.Fire, 50, 60);
+      SetResistance(ResistanceType.Cold, 60, 70);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.MagicResist, 50.1, 75.0);
+      SetSkill(SkillName.Tactics, 75.1, 100.0);
+      SetSkill(SkillName.Wrestling, 70.1, 90.0);
+
+      Fame = 3500;
+      Karma = -3500;
+
+      VirtualArmor = 54;
+    }
+
+    public Ravager(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a ravager corpse";
+
+    public override string DefaultName => "a ravager";
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return Utility.RandomBool() ? WeaponAbility.Dismount : WeaponAbility.CrushingBlow;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/Revenant.cs

@@ -0,0 +1,172 @@
+using System;
+using Server.Items;
+using Server.Targeting;
+
+namespace Server.Mobiles
+{
+  public class Revenant : BaseCreature
+  {
+    private DateTime m_ExpireTime;
+    private Mobile m_Target;
+
+    public Revenant(Mobile caster, Mobile target, TimeSpan duration) : base(AIType.AI_Melee, FightMode.Closest, 10, 1,
+      0.18, 0.36)
+    {
+      Body = 400;
+      Hue = 1;
+      // TODO: Sound values?
+
+      double scalar = caster.Skills.SpiritSpeak.Value * 0.01;
+
+      m_Target = target;
+      m_ExpireTime = DateTime.UtcNow + duration;
+
+      SetStr(200);
+      SetDex(150);
+      SetInt(150);
+
+      SetDamage(16, 17);
+
+      // Bestiary says 50 phys 50 cold, animal lore says differently
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetSkill(SkillName.MagicResist, 100.0 * scalar); // magic resist is absolute value of spiritspeak
+      SetSkill(SkillName.Tactics, 100.0); // always 100
+      SetSkill(SkillName.Swords,
+        100.0 * scalar); // not displayed in animal lore but tests clearly show this is influenced
+      SetSkill(SkillName.DetectHidden, 75.0 * scalar);
+
+      scalar /= 1.2;
+
+      SetResistance(ResistanceType.Physical, 40 + (int)(20 * scalar), 50 + (int)(20 * scalar));
+      SetResistance(ResistanceType.Cold, 40 + (int)(20 * scalar), 50 + (int)(20 * scalar));
+      SetResistance(ResistanceType.Fire, (int)(20 * scalar));
+      SetResistance(ResistanceType.Poison, 100);
+      SetResistance(ResistanceType.Energy, 40 + (int)(20 * scalar), 50 + (int)(20 * scalar));
+
+      Fame = 0;
+      Karma = 0;
+
+      ControlSlots = 3;
+
+      VirtualArmor = 32;
+
+      AddItem(new DeathShroud { Hue = 0x455, Movable = false });
+      AddItem(new Halberd { Hue = 1, Movable = false });
+    }
+
+    public Revenant(Serial serial) : base(serial)
+    {
+    }
+
+    public override Mobile ConstantFocus => m_Target;
+    public override bool NoHouseRestrictions => true;
+
+    public override double DispelDifficulty => 80.0;
+    public override double DispelFocus => 20.0;
+
+    public override string DefaultName => "a revenant";
+
+    public override bool AlwaysMurderer => true;
+
+    public override bool BleedImmune => true;
+    public override bool BardImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override void DisplayPaperdollTo(Mobile to)
+    {
+      // Do nothing
+    }
+
+    public override void OnThink()
+    {
+      if (!m_Target.Alive || DateTime.UtcNow > m_ExpireTime)
+      {
+        Kill();
+        return;
+      }
+
+      if (Map != m_Target.Map || !InRange(m_Target, 15))
+      {
+        Map fromMap = Map;
+        Point3D from = Location;
+
+        Map toMap = m_Target.Map;
+        Point3D to = m_Target.Location;
+
+        if (toMap != null)
+          for (int i = 0; i < 5; ++i)
+          {
+            Point3D loc = new Point3D(to.X - 4 + Utility.Random(9), to.Y - 4 + Utility.Random(9), to.Z);
+
+            if (toMap.CanSpawnMobile(loc))
+            {
+              to = loc;
+              break;
+            }
+
+            loc.Z = toMap.GetAverageZ(loc.X, loc.Y);
+
+            if (toMap.CanSpawnMobile(loc))
+            {
+              to = loc;
+              break;
+            }
+          }
+
+        Map = toMap;
+        Location = to;
+
+        ProcessDelta();
+
+        Effects.SendLocationParticles(EffectItem.Create(from, fromMap, EffectItem.DefaultDuration), 0x3728, 1, 13,
+          37, 7, 5023, 0);
+        FixedParticles(0x3728, 1, 13, 5023, 37, 7, EffectLayer.Waist);
+
+        PlaySound(0x37D);
+      }
+
+      if (m_Target.Hidden && InRange(m_Target, 3) && Core.TickCount - NextSkillTime >= 0 &&
+          UseSkill(SkillName.DetectHidden))
+      {
+        Target targ = Target;
+
+        targ?.Invoke(this, this);
+      }
+
+      Combatant = m_Target;
+      FocusMob = m_Target;
+
+      if (AIObject != null)
+        AIObject.Action = ActionType.Combat;
+
+      base.OnThink();
+    }
+
+    public override bool OnBeforeDeath()
+    {
+      Effects.PlaySound(Location, Map, 0x10B);
+      Effects.SendLocationParticles(EffectItem.Create(Location, Map, TimeSpan.FromSeconds(10.0)), 0x37CC, 1, 50, 2101,
+        7, 9909, 0);
+
+      Delete();
+      return false;
+    }
+
+    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();
+
+      Delete();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/ShadowKnight.cs

@@ -0,0 +1,193 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class ShadowKnight : BaseCreature
+  {
+    private bool m_HasTeleportedAway;
+
+    private Timer m_SoundTimer;
+
+    [Constructible]
+    public ShadowKnight() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("shadow knight");
+      Title = "the Shadow Knight";
+      Body = 311;
+
+      SetStr(250);
+      SetDex(100);
+      SetInt(100);
+
+      SetHits(2000);
+
+      SetDamage(20, 30);
+
+      SetDamageType(ResistanceType.Physical, 60);
+      SetDamageType(ResistanceType.Cold, 40);
+
+      SetResistance(ResistanceType.Physical, 90);
+      SetResistance(ResistanceType.Fire, 65);
+      SetResistance(ResistanceType.Cold, 75);
+      SetResistance(ResistanceType.Poison, 75);
+      SetResistance(ResistanceType.Energy, 55);
+
+      SetSkill(SkillName.Chivalry, 120.0);
+      SetSkill(SkillName.DetectHidden, 80.0);
+      SetSkill(SkillName.EvalInt, 100.0);
+      SetSkill(SkillName.Magery, 100.0);
+      SetSkill(SkillName.Meditation, 100.0);
+      SetSkill(SkillName.MagicResist, 120.0);
+      SetSkill(SkillName.Tactics, 100.0);
+      SetSkill(SkillName.Wrestling, 100.0);
+
+      Fame = 25000;
+      Karma = -25000;
+
+      VirtualArmor = 54;
+    }
+
+    public ShadowKnight(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a shadow knight corpse";
+
+    public override bool IgnoreYoungProtection => Core.ML;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override bool BardImmune => !Core.SE;
+    public override bool Unprovokable => Core.SE;
+    public override bool AreaPeaceImmune => Core.SE;
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override int TreasureMapLevel => 1;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return Utility.RandomBool() ? WeaponAbility.ConcussionBlow : WeaponAbility.CrushingBlow;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.UltraRich, 2);
+    }
+
+    public override void OnDeath(Container c)
+    {
+      base.OnDeath(c);
+
+      if (!Summoned && !NoKillAwards && DemonKnight.CheckArtifactChance(this))
+        DemonKnight.DistributeArtifact(this);
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x2CE;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x2C1;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x2D1;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x2C8;
+    }
+
+    public override void OnCombatantChange()
+    {
+      base.OnCombatantChange();
+
+      if (Hidden && Combatant != null)
+        Combatant = null;
+    }
+
+    public virtual void SendTrackingSound()
+    {
+      if (Hidden)
+      {
+        Effects.PlaySound(Location, Map, 0x2C8);
+        Combatant = null;
+      }
+      else
+      {
+        Frozen = false;
+
+        m_SoundTimer?.Stop();
+
+        m_SoundTimer = null;
+      }
+    }
+
+    public override void OnThink()
+    {
+      if (!m_HasTeleportedAway && Hits < HitsMax / 2)
+      {
+        Map map = Map;
+
+        if (map != null)
+          for (int i = 0; i < 10; ++i)
+          {
+            int x = X + Utility.RandomMinMax(5, 10) * (Utility.RandomBool() ? 1 : -1);
+            int y = Y + Utility.RandomMinMax(5, 10) * (Utility.RandomBool() ? 1 : -1);
+            int z = Z;
+
+            if (!map.CanFit(x, y, z, 16, false, false))
+              continue;
+
+            Point3D from = Location;
+            Point3D to = new Point3D(x, y, z);
+
+            if (!InLOS(to))
+              continue;
+
+            Location = to;
+            ProcessDelta();
+            Hidden = true;
+            Combatant = null;
+
+            Effects.SendLocationParticles(EffectItem.Create(from, map, EffectItem.DefaultDuration), 0x3728, 10,
+              10, 2023);
+            Effects.SendLocationParticles(EffectItem.Create(to, map, EffectItem.DefaultDuration), 0x3728, 10, 10,
+              5023);
+
+            Effects.PlaySound(to, map, 0x1FE);
+
+            m_HasTeleportedAway = true;
+            m_SoundTimer = Timer.DelayCall(TimeSpan.FromSeconds(5.0), TimeSpan.FromSeconds(2.5),
+              SendTrackingSound);
+
+            Frozen = true;
+
+            break;
+          }
+      }
+
+      base.OnThink();
+    }
+
+    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();
+
+      if (BaseSoundID == 357)
+        BaseSoundID = -1;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/SkitteringHopper.cs

@@ -0,0 +1,65 @@
+namespace Server.Mobiles
+{
+  public class SkitteringHopper : BaseCreature
+  {
+    [Constructible]
+    public SkitteringHopper() : base(AIType.AI_Melee, FightMode.Aggressor, 10, 1, 0.2, 0.4)
+    {
+      Body = 302;
+      BaseSoundID = 959;
+
+      SetStr(41, 65);
+      SetDex(91, 115);
+      SetInt(26, 50);
+
+      SetHits(31, 45);
+
+      SetDamage(3, 5);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 5, 10);
+      SetResistance(ResistanceType.Cold, 10, 20);
+      SetResistance(ResistanceType.Energy, 5, 10);
+
+      SetSkill(SkillName.MagicResist, 30.1, 45.0);
+      SetSkill(SkillName.Tactics, 45.1, 70.0);
+      SetSkill(SkillName.Wrestling, 40.1, 60.0);
+
+      Fame = 300;
+      Karma = 0;
+
+      Tamable = true;
+      ControlSlots = 1;
+      MinTameSkill = -12.9;
+
+      VirtualArmor = 12;
+    }
+
+    public SkitteringHopper(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a skittering hopper corpse";
+    public override string DefaultName => "a skittering hopper";
+
+    public override int TreasureMapLevel => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/Treefellow.cs

@@ -0,0 +1,90 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Treefellow : BaseCreature
+  {
+    [Constructible]
+    public Treefellow() : base(AIType.AI_Melee, FightMode.Evil, 10, 1, 0.2, 0.4)
+    {
+      Body = 301;
+
+      SetStr(196, 220);
+      SetDex(31, 55);
+      SetInt(66, 90);
+
+      SetHits(118, 132);
+
+      SetDamage(12, 16);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 20, 25);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 30, 35);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.MagicResist, 40.1, 55.0);
+      SetSkill(SkillName.Tactics, 65.1, 90.0);
+      SetSkill(SkillName.Wrestling, 65.1, 85.0);
+
+      Fame = 500;
+      Karma = 1500;
+
+      VirtualArmor = 24;
+      PackItem(new Log(Utility.RandomMinMax(23, 34)));
+    }
+
+    public Treefellow(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a treefellow corpse";
+
+    public override string DefaultName => "a treefellow";
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override bool BleedImmune => true;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return WeaponAbility.Dismount;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 443;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 31;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 672;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+    }
+
+    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();
+
+      if (BaseSoundID == 442)
+        BaseSoundID = -1;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/VampireBat.cs

@@ -0,0 +1,67 @@
+namespace Server.Mobiles
+{
+  public class VampireBat : BaseCreature
+  {
+    [Constructible]
+    public VampireBat() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 317;
+      BaseSoundID = 0x270;
+
+      SetStr(91, 110);
+      SetDex(91, 115);
+      SetInt(26, 50);
+
+      SetHits(55, 66);
+
+      SetDamage(7, 9);
+
+      SetDamageType(ResistanceType.Physical, 80);
+      SetDamageType(ResistanceType.Poison, 20);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 15, 25);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 60, 70);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.MagicResist, 70.1, 95.0);
+      SetSkill(SkillName.Tactics, 55.1, 80.0);
+      SetSkill(SkillName.Wrestling, 30.1, 55.0);
+
+      Fame = 1000;
+      Karma = -1000;
+
+      VirtualArmor = 14;
+    }
+
+    public VampireBat(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a vampire bat corpse";
+    public override string DefaultName => "a vampire bat";
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Poor);
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x29B;
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/WailingBanshee.cs

@@ -0,0 +1,73 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class WailingBanshee : BaseCreature
+  {
+    [Constructible]
+    public WailingBanshee() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 310;
+      BaseSoundID = 0x482;
+
+      SetStr(126, 150);
+      SetDex(76, 100);
+      SetInt(86, 110);
+
+      SetHits(76, 90);
+
+      SetDamage(10, 14);
+
+      SetDamageType(ResistanceType.Physical, 20);
+      SetDamageType(ResistanceType.Cold, 60);
+      SetDamageType(ResistanceType.Poison, 20);
+
+      SetResistance(ResistanceType.Physical, 50, 60);
+      SetResistance(ResistanceType.Fire, 25, 30);
+      SetResistance(ResistanceType.Cold, 70, 80);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.MagicResist, 70.1, 95.0);
+      SetSkill(SkillName.Tactics, 45.1, 70.0);
+      SetSkill(SkillName.Wrestling, 50.1, 70.0);
+
+      Fame = 1500;
+      Karma = -1500;
+
+      VirtualArmor = 19;
+    }
+
+    public WailingBanshee(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a wailing banshee corpse";
+
+    public override string DefaultName => "a wailing banshee";
+
+    public override bool BleedImmune => true;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return WeaponAbility.MortalStrike;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/AOS/WandererOfTheVoid.cs

@@ -0,0 +1,77 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class WandererOfTheVoid : BaseCreature
+  {
+    [Constructible]
+    public WandererOfTheVoid() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 316;
+      BaseSoundID = 377;
+
+      SetStr(111, 200);
+      SetDex(101, 125);
+      SetInt(301, 390);
+
+      SetHits(351, 400);
+
+      SetDamage(11, 13);
+
+      SetDamageType(ResistanceType.Physical, 0);
+      SetDamageType(ResistanceType.Cold, 15);
+      SetDamageType(ResistanceType.Energy, 85);
+
+      SetResistance(ResistanceType.Physical, 40, 50);
+      SetResistance(ResistanceType.Fire, 15, 25);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 50, 75);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.EvalInt, 60.1, 70.0);
+      SetSkill(SkillName.Magery, 60.1, 70.0);
+      SetSkill(SkillName.Meditation, 60.1, 70.0);
+      SetSkill(SkillName.MagicResist, 50.1, 75.0);
+      SetSkill(SkillName.Tactics, 60.1, 70.0);
+      SetSkill(SkillName.Wrestling, 60.1, 70.0);
+
+      Fame = 20000;
+      Karma = -20000;
+
+      VirtualArmor = 44;
+
+      int count = Utility.RandomMinMax(2, 3);
+
+      for (int i = 0; i < count; ++i)
+        PackItem(new TreasureMap(3, Map.Trammel));
+    }
+
+    public WandererOfTheVoid(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a wanderer of the void corpse";
+    public override string DefaultName => "a wanderer of the void";
+
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override int TreasureMapLevel => Core.AOS ? 4 : 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Ants/AntLion.cs

@@ -0,0 +1,121 @@
+using Server.Engines.Plants;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class AntLion : BaseCreature
+  {
+    [Constructible]
+    public AntLion() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 787;
+      BaseSoundID = 1006;
+
+      SetStr(296, 320);
+      SetDex(81, 105);
+      SetInt(36, 60);
+
+      SetHits(151, 162);
+
+      SetDamage(7, 21);
+
+      SetDamageType(ResistanceType.Physical, 70);
+      SetDamageType(ResistanceType.Poison, 30);
+
+      SetResistance(ResistanceType.Physical, 45, 60);
+      SetResistance(ResistanceType.Fire, 25, 35);
+      SetResistance(ResistanceType.Cold, 30, 40);
+      SetResistance(ResistanceType.Poison, 40, 50);
+      SetResistance(ResistanceType.Energy, 30, 35);
+
+      SetSkill(SkillName.MagicResist, 70.0);
+      SetSkill(SkillName.Tactics, 90.0);
+      SetSkill(SkillName.Wrestling, 90.0);
+
+      Fame = 4500;
+      Karma = -4500;
+
+      VirtualArmor = 45;
+
+      PackItem(new Bone(3));
+      PackItem(new FertileDirt(Utility.RandomMinMax(1, 5)));
+
+      if (Core.ML && Utility.RandomDouble() < .33)
+        PackItem(Seed.RandomPeculiarSeed(2));
+
+      Item orepile = null; /* no trust, no love :( */
+
+      switch (Utility.Random(4))
+      {
+        case 0:
+          orepile = new DullCopperOre();
+          break;
+        case 1:
+          orepile = new ShadowIronOre();
+          break;
+        case 2:
+          orepile = new CopperOre();
+          break;
+        default:
+          orepile = new BronzeOre();
+          break;
+      }
+
+      orepile.Amount = Utility.RandomMinMax(1, 10);
+      orepile.ItemID = 0x19B9;
+      PackItem(orepile);
+
+      // TODO: skeleton
+    }
+
+
+    public AntLion(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an ant lion corpse";
+    public override string DefaultName => "an ant lion";
+
+    public override int GetAngerSound()
+    {
+      return 0x5A;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x5A;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x164;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x187;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x1BA;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average, 2);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Ants/BlackSolenInfiltratorQueen.cs

@@ -0,0 +1,108 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class BlackSolenInfiltratorQueen : BaseCreature
+  {
+    [Constructible]
+    public BlackSolenInfiltratorQueen() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 807;
+      BaseSoundID = 959;
+      Hue = 0x453;
+
+      SetStr(326, 350);
+      SetDex(141, 165);
+      SetInt(96, 120);
+
+      SetHits(151, 162);
+
+      SetDamage(10, 15);
+
+      SetDamageType(ResistanceType.Physical, 70);
+      SetDamageType(ResistanceType.Poison, 30);
+
+      SetResistance(ResistanceType.Physical, 30, 40);
+      SetResistance(ResistanceType.Fire, 30, 35);
+      SetResistance(ResistanceType.Cold, 25, 35);
+      SetResistance(ResistanceType.Poison, 35, 40);
+      SetResistance(ResistanceType.Energy, 25, 30);
+
+      SetSkill(SkillName.MagicResist, 90.0);
+      SetSkill(SkillName.Tactics, 90.0);
+      SetSkill(SkillName.Wrestling, 90.0);
+
+      Fame = 6500;
+      Karma = -6500;
+
+      VirtualArmor = 50;
+
+      SolenHelper.PackPicnicBasket(this);
+
+      PackItem(new ZoogiFungus(0.05 > Utility.RandomDouble() ? 16 : 4));
+    }
+
+    public BlackSolenInfiltratorQueen(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a solen infiltrator corpse";
+    public override string DefaultName => "a black solen infiltrator";
+
+    public override int GetAngerSound()
+    {
+      return 0x259;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x259;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x195;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x250;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x25B;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+    }
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (SolenHelper.CheckBlackFriendship(m))
+        return false;
+      return base.IsEnemy(m);
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      SolenHelper.OnBlackDamage(from);
+
+      base.OnDamage(amount, from, willKill);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Ants/BlackSolenInfiltratorWarrior.cs

@@ -0,0 +1,109 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class BlackSolenInfiltratorWarrior : BaseCreature
+  {
+    [Constructible]
+    public BlackSolenInfiltratorWarrior() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 806;
+      BaseSoundID = 959;
+      Hue = 0x453;
+
+      SetStr(206, 230);
+      SetDex(121, 145);
+      SetInt(66, 90);
+
+      SetHits(96, 107);
+
+      SetDamage(5, 15);
+
+      SetDamageType(ResistanceType.Physical, 80);
+      SetDamageType(ResistanceType.Poison, 20);
+
+      SetResistance(ResistanceType.Physical, 20, 35);
+      SetResistance(ResistanceType.Fire, 20, 35);
+      SetResistance(ResistanceType.Cold, 10, 25);
+      SetResistance(ResistanceType.Poison, 20, 35);
+      SetResistance(ResistanceType.Energy, 10, 25);
+
+      SetSkill(SkillName.MagicResist, 80.0);
+      SetSkill(SkillName.Tactics, 80.0);
+      SetSkill(SkillName.Wrestling, 80.0);
+
+      Fame = 3000;
+      Karma = -3000;
+
+      VirtualArmor = 40;
+
+      SolenHelper.PackPicnicBasket(this);
+
+      PackItem(new ZoogiFungus(0.05 > Utility.RandomDouble() ? 13 : 3));
+    }
+
+    public BlackSolenInfiltratorWarrior(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a solen infiltrator corpse";
+    public override string DefaultName => "a black solen infiltrator";
+
+    public override int GetAngerSound()
+    {
+      return 0xB5;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0xB5;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x289;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0xBC;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0xE4;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average, 2);
+      AddLoot(LootPack.Gems, Utility.RandomMinMax(1, 4));
+    }
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (SolenHelper.CheckBlackFriendship(m))
+        return false;
+      return base.IsEnemy(m);
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      SolenHelper.OnBlackDamage(from);
+
+      base.OnDamage(amount, from, willKill);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Ants/BlackSolenQueen.cs

@@ -0,0 +1,147 @@
+using Server.Items;
+using Server.Network;
+
+namespace Server.Mobiles
+{
+  public class BlackSolenQueen : BaseCreature
+  {
+    [Constructible]
+    public BlackSolenQueen() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 807;
+      BaseSoundID = 959;
+      Hue = 0x453;
+
+      SetStr(296, 320);
+      SetDex(121, 145);
+      SetInt(76, 100);
+
+      SetHits(151, 162);
+
+      SetDamage(10, 15);
+
+      SetDamageType(ResistanceType.Physical, 70);
+      SetDamageType(ResistanceType.Poison, 30);
+
+      SetResistance(ResistanceType.Physical, 30, 40);
+      SetResistance(ResistanceType.Fire, 30, 35);
+      SetResistance(ResistanceType.Cold, 25, 35);
+      SetResistance(ResistanceType.Poison, 35, 40);
+      SetResistance(ResistanceType.Energy, 25, 30);
+
+      SetSkill(SkillName.MagicResist, 70.0);
+      SetSkill(SkillName.Tactics, 90.0);
+      SetSkill(SkillName.Wrestling, 90.0);
+
+      Fame = 4500;
+      Karma = -4500;
+
+      VirtualArmor = 45;
+
+      SolenHelper.PackPicnicBasket(this);
+
+      PackItem(new ZoogiFungus(Utility.RandomDouble() > 0.05 ? 5 : 25));
+
+      if (Utility.RandomDouble() < 0.05)
+        PackItem(new BallOfSummoning());
+    }
+
+    public BlackSolenQueen(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a solen queen corpse";
+    public bool BurstSac{ get; private set; }
+
+    public override string DefaultName => "a black solen queen";
+
+    public override int GetAngerSound()
+    {
+      return 0x259;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x259;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x195;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x250;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x25B;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+    }
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (SolenHelper.CheckBlackFriendship(m))
+        return false;
+      return base.IsEnemy(m);
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      SolenHelper.OnBlackDamage(from);
+
+      if (!willKill)
+      {
+        if (!BurstSac)
+        {
+          if (Hits < 50)
+          {
+            PublicOverheadMessage(MessageType.Regular, 0x3B2, true, "* The solen's acid sac is burst open! *");
+            BurstSac = true;
+          }
+        }
+        else if (from != null && from != this && InRange(from, 1))
+        {
+          SpillAcid(from, 1);
+        }
+      }
+
+      base.OnDamage(amount, from, willKill);
+    }
+
+    public override bool OnBeforeDeath()
+    {
+      SpillAcid(4);
+
+      return base.OnBeforeDeath();
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(1);
+      writer.Write(BurstSac);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 1:
+        {
+          BurstSac = reader.ReadBool();
+          break;
+        }
+      }
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Ants/BlackSolenWarrior.cs

@@ -0,0 +1,148 @@
+using Server.Items;
+using Server.Network;
+
+namespace Server.Mobiles
+{
+  public class BlackSolenWarrior : BaseCreature
+  {
+    [Constructible]
+    public BlackSolenWarrior() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 806;
+      BaseSoundID = 959;
+      Hue = 0x453;
+
+      SetStr(196, 220);
+      SetDex(101, 125);
+      SetInt(36, 60);
+
+      SetHits(96, 107);
+
+      SetDamage(5, 15);
+
+      SetDamageType(ResistanceType.Physical, 80);
+      SetDamageType(ResistanceType.Poison, 20);
+
+      SetResistance(ResistanceType.Physical, 20, 35);
+      SetResistance(ResistanceType.Fire, 20, 35);
+      SetResistance(ResistanceType.Cold, 10, 25);
+      SetResistance(ResistanceType.Poison, 20, 35);
+      SetResistance(ResistanceType.Energy, 10, 25);
+
+      SetSkill(SkillName.MagicResist, 60.0);
+      SetSkill(SkillName.Tactics, 80.0);
+      SetSkill(SkillName.Wrestling, 80.0);
+
+      Fame = 3000;
+      Karma = -3000;
+
+      VirtualArmor = 35;
+
+      SolenHelper.PackPicnicBasket(this);
+
+      PackItem(new ZoogiFungus(0.05 > Utility.RandomDouble() ? 13 : 3));
+
+      if (Utility.RandomDouble() < 0.05)
+        PackItem(new BraceletOfBinding());
+    }
+
+    public BlackSolenWarrior(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a solen warrior corpse";
+    public bool BurstSac{ get; private set; }
+
+    public override string DefaultName => "a black solen warrior";
+
+    public override int GetAngerSound()
+    {
+      return 0xB5;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0xB5;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x289;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0xBC;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0xE4;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Gems, Utility.RandomMinMax(1, 4));
+    }
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (SolenHelper.CheckBlackFriendship(m))
+        return false;
+      return base.IsEnemy(m);
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      SolenHelper.OnBlackDamage(from);
+
+      if (!willKill)
+      {
+        if (!BurstSac)
+        {
+          if (Hits < 50)
+          {
+            PublicOverheadMessage(MessageType.Regular, 0x3B2, true, "* The solen's acid sac is burst open! *");
+            BurstSac = true;
+          }
+        }
+        else if (from != null && from != this && InRange(from, 1))
+        {
+          SpillAcid(from, 1);
+        }
+      }
+
+      base.OnDamage(amount, from, willKill);
+    }
+
+    public override bool OnBeforeDeath()
+    {
+      SpillAcid(4);
+
+      return base.OnBeforeDeath();
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(1);
+      writer.Write(BurstSac);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 1:
+        {
+          BurstSac = reader.ReadBool();
+          break;
+        }
+      }
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Ants/BlackSolenWorker.cs

@@ -0,0 +1,109 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class BlackSolenWorker : BaseCreature
+  {
+    [Constructible]
+    public BlackSolenWorker() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 805;
+      BaseSoundID = 959;
+      Hue = 0x453;
+
+      SetStr(96, 120);
+      SetDex(81, 105);
+      SetInt(36, 60);
+
+      SetHits(58, 72);
+
+      SetDamage(5, 7);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 25, 30);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 10, 20);
+      SetResistance(ResistanceType.Poison, 10, 20);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.MagicResist, 60.0);
+      SetSkill(SkillName.Tactics, 65.0);
+      SetSkill(SkillName.Wrestling, 60.0);
+
+      Fame = 1500;
+      Karma = -1500;
+
+      VirtualArmor = 28;
+
+      PackGold(Utility.Random(100, 180));
+
+      SolenHelper.PackPicnicBasket(this);
+
+      PackItem(new ZoogiFungus());
+    }
+
+    public BlackSolenWorker(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a solen worker corpse";
+    public override string DefaultName => "a black solen worker";
+
+    public override int GetAngerSound()
+    {
+      return 0x269;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x269;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x186;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x1BE;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x8E;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Gems, Utility.RandomMinMax(1, 2));
+    }
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (SolenHelper.CheckBlackFriendship(m))
+        return false;
+      return base.IsEnemy(m);
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      SolenHelper.OnBlackDamage(from);
+
+      base.OnDamage(amount, from, willKill);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Ants/RedSolenInfiltratorQueen.cs

@@ -0,0 +1,107 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class RedSolenInfiltratorQueen : BaseCreature
+  {
+    [Constructible]
+    public RedSolenInfiltratorQueen() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 783;
+      BaseSoundID = 959;
+
+      SetStr(326, 350);
+      SetDex(141, 165);
+      SetInt(96, 120);
+
+      SetHits(151, 162);
+
+      SetDamage(10, 15);
+
+      SetDamageType(ResistanceType.Physical, 70);
+      SetDamageType(ResistanceType.Poison, 30);
+
+      SetResistance(ResistanceType.Physical, 30, 40);
+      SetResistance(ResistanceType.Fire, 30, 35);
+      SetResistance(ResistanceType.Cold, 25, 35);
+      SetResistance(ResistanceType.Poison, 35, 40);
+      SetResistance(ResistanceType.Energy, 25, 30);
+
+      SetSkill(SkillName.MagicResist, 90.0);
+      SetSkill(SkillName.Tactics, 90.0);
+      SetSkill(SkillName.Wrestling, 90.0);
+
+      Fame = 6500;
+      Karma = -6500;
+
+      VirtualArmor = 50;
+
+      SolenHelper.PackPicnicBasket(this);
+
+      PackItem(new ZoogiFungus(0.05 < Utility.RandomDouble() ? 4 : 16));
+    }
+
+    public RedSolenInfiltratorQueen(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a solen infiltrator corpse";
+    public override string DefaultName => "a red solen infiltrator";
+
+    public override int GetAngerSound()
+    {
+      return 0x259;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x259;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x195;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x250;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x25B;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+    }
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (SolenHelper.CheckRedFriendship(m))
+        return false;
+      return base.IsEnemy(m);
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      SolenHelper.OnRedDamage(from);
+
+      base.OnDamage(amount, from, willKill);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Ants/RedSolenInfiltratorWarrior.cs

@@ -0,0 +1,108 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class RedSolenInfiltratorWarrior : BaseCreature
+  {
+    [Constructible]
+    public RedSolenInfiltratorWarrior() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 782;
+      BaseSoundID = 959;
+
+      SetStr(206, 230);
+      SetDex(121, 145);
+      SetInt(66, 90);
+
+      SetHits(96, 107);
+
+      SetDamage(5, 15);
+
+      SetDamageType(ResistanceType.Physical, 80);
+      SetDamageType(ResistanceType.Poison, 20);
+
+      SetResistance(ResistanceType.Physical, 20, 35);
+      SetResistance(ResistanceType.Fire, 20, 35);
+      SetResistance(ResistanceType.Cold, 10, 25);
+      SetResistance(ResistanceType.Poison, 20, 35);
+      SetResistance(ResistanceType.Energy, 10, 25);
+
+      SetSkill(SkillName.MagicResist, 80.0);
+      SetSkill(SkillName.Tactics, 80.0);
+      SetSkill(SkillName.Wrestling, 80.0);
+
+      Fame = 3000;
+      Karma = -3000;
+
+      VirtualArmor = 40;
+
+      SolenHelper.PackPicnicBasket(this);
+
+      PackItem(new ZoogiFungus(0.05 < Utility.RandomDouble() ? 3 : 13));
+    }
+
+    public RedSolenInfiltratorWarrior(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a solen infiltrator corpse";
+    public override string DefaultName => "a red solen infiltrator";
+
+    public override int GetAngerSound()
+    {
+      return 0xB5;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0xB5;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x289;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0xBC;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0xE4;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average, 2);
+      AddLoot(LootPack.Gems, Utility.RandomMinMax(1, 4));
+    }
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (SolenHelper.CheckRedFriendship(m))
+        return false;
+      return base.IsEnemy(m);
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      SolenHelper.OnRedDamage(from);
+
+      base.OnDamage(amount, from, willKill);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Ants/RedSolenQueen.cs

@@ -0,0 +1,147 @@
+using Server.Items;
+using Server.Network;
+
+namespace Server.Mobiles
+{
+  public class RedSolenQueen : BaseCreature
+  {
+    [Constructible]
+    public RedSolenQueen() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 783;
+      BaseSoundID = 959;
+
+      SetStr(296, 320);
+      SetDex(121, 145);
+      SetInt(76, 100);
+
+      SetHits(151, 162);
+
+      SetDamage(10, 15);
+
+      SetDamageType(ResistanceType.Physical, 70);
+      SetDamageType(ResistanceType.Poison, 30);
+
+      SetResistance(ResistanceType.Physical, 30, 40);
+      SetResistance(ResistanceType.Fire, 30, 35);
+      SetResistance(ResistanceType.Cold, 25, 35);
+      SetResistance(ResistanceType.Poison, 35, 40);
+      SetResistance(ResistanceType.Energy, 25, 30);
+
+      SetSkill(SkillName.MagicResist, 70.0);
+      SetSkill(SkillName.Tactics, 90.0);
+      SetSkill(SkillName.Wrestling, 90.0);
+
+      Fame = 4500;
+      Karma = -4500;
+
+      VirtualArmor = 45;
+
+      SolenHelper.PackPicnicBasket(this);
+
+      PackItem(new ZoogiFungus(Utility.RandomDouble() > 0.05 ? 5 : 25));
+
+      if (Utility.RandomDouble() < 0.05)
+        PackItem(new BallOfSummoning());
+    }
+
+    public RedSolenQueen(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a solen queen corpse";
+    public bool BurstSac{ get; private set; }
+
+    public override string DefaultName => "a red solen queen";
+
+    public override int GetAngerSound()
+    {
+      return 0x259;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x259;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x195;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x250;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x25B;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+    }
+
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (SolenHelper.CheckRedFriendship(m))
+        return false;
+      return base.IsEnemy(m);
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      SolenHelper.OnRedDamage(from);
+
+      if (!willKill)
+      {
+        if (!BurstSac)
+        {
+          if (Hits < 50)
+          {
+            PublicOverheadMessage(MessageType.Regular, 0x3B2, true, "* The solen's acid sac is burst open! *");
+            BurstSac = true;
+          }
+        }
+        else if (from != null && from != this && InRange(from, 1))
+        {
+          SpillAcid(from, 1);
+        }
+      }
+
+      base.OnDamage(amount, from, willKill);
+    }
+
+    public override bool OnBeforeDeath()
+    {
+      SpillAcid(4);
+
+      return base.OnBeforeDeath();
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(1);
+      writer.Write(BurstSac);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 1:
+        {
+          BurstSac = reader.ReadBool();
+          break;
+        }
+      }
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Ants/RedSolenWarrior.cs

@@ -0,0 +1,146 @@
+using Server.Items;
+using Server.Network;
+
+namespace Server.Mobiles
+{
+  public class RedSolenWarrior : BaseCreature
+  {
+    [Constructible]
+    public RedSolenWarrior() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 782;
+      BaseSoundID = 959;
+
+      SetStr(196, 220);
+      SetDex(101, 125);
+      SetInt(36, 60);
+
+      SetHits(96, 107);
+
+      SetDamage(5, 15);
+
+      SetDamageType(ResistanceType.Physical, 80);
+      SetDamageType(ResistanceType.Poison, 20);
+
+      SetResistance(ResistanceType.Physical, 20, 35);
+      SetResistance(ResistanceType.Fire, 20, 35);
+      SetResistance(ResistanceType.Cold, 10, 25);
+      SetResistance(ResistanceType.Poison, 20, 35);
+      SetResistance(ResistanceType.Energy, 10, 25);
+
+      SetSkill(SkillName.MagicResist, 60.0);
+      SetSkill(SkillName.Tactics, 80.0);
+      SetSkill(SkillName.Wrestling, 80.0);
+
+      Fame = 3000;
+      Karma = -3000;
+
+      VirtualArmor = 35;
+
+      SolenHelper.PackPicnicBasket(this);
+      PackItem(new ZoogiFungus(0.05 < Utility.RandomDouble() ? 3 : 13));
+
+      if (Utility.RandomDouble() < 0.05)
+        PackItem(new BraceletOfBinding());
+    }
+
+    public RedSolenWarrior(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a solen warrior corpse";
+    public bool BurstSac{ get; private set; }
+
+    public override string DefaultName => "a red solen warrior";
+
+    public override int GetAngerSound()
+    {
+      return 0xB5;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0xB5;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x289;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0xBC;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0xE4;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Gems, Utility.RandomMinMax(1, 4));
+    }
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (SolenHelper.CheckRedFriendship(m))
+        return false;
+      return base.IsEnemy(m);
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      SolenHelper.OnRedDamage(from);
+
+      if (!willKill)
+      {
+        if (!BurstSac)
+        {
+          if (Hits < 50)
+          {
+            PublicOverheadMessage(MessageType.Regular, 0x3B2, true, "* The solen's acid sac is burst open! *");
+            BurstSac = true;
+          }
+        }
+        else if (from != null && from != this && InRange(from, 1))
+        {
+          SpillAcid(from, 1);
+        }
+      }
+
+      base.OnDamage(amount, from, willKill);
+    }
+
+    public override bool OnBeforeDeath()
+    {
+      SpillAcid(4);
+
+      return base.OnBeforeDeath();
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(1);
+      writer.Write(BurstSac);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 1:
+        {
+          BurstSac = reader.ReadBool();
+          break;
+        }
+      }
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Ants/RedSolenWorker.cs

@@ -0,0 +1,108 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class RedSolenWorker : BaseCreature
+  {
+    [Constructible]
+    public RedSolenWorker() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 781;
+      BaseSoundID = 959;
+
+      SetStr(96, 120);
+      SetDex(81, 105);
+      SetInt(36, 60);
+
+      SetHits(58, 72);
+
+      SetDamage(5, 7);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 25, 30);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 10, 20);
+      SetResistance(ResistanceType.Poison, 10, 20);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.MagicResist, 60.0);
+      SetSkill(SkillName.Tactics, 65.0);
+      SetSkill(SkillName.Wrestling, 60.0);
+
+      Fame = 1500;
+      Karma = -1500;
+
+      VirtualArmor = 28;
+
+      PackGold(Utility.Random(100, 180));
+
+      SolenHelper.PackPicnicBasket(this);
+
+      PackItem(new ZoogiFungus());
+    }
+
+    public RedSolenWorker(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a solen worker corpse";
+    public override string DefaultName => "a red solen worker";
+
+    public override int GetAngerSound()
+    {
+      return 0x269;
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x269;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x186;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x1BE;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x8E;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Gems, Utility.RandomMinMax(1, 2));
+    }
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (SolenHelper.CheckRedFriendship(m))
+        return false;
+      return base.IsEnemy(m);
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      SolenHelper.OnRedDamage(from);
+
+      base.OnDamage(amount, from, willKill);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Ants/SolenHelper.cs

@@ -0,0 +1,85 @@
+using Server.Items;
+using Server.Network;
+
+namespace Server.Mobiles
+{
+  public class SolenHelper
+  {
+    public static void PackPicnicBasket(BaseCreature solen)
+    {
+      if (1 > Utility.Random(100))
+      {
+        PicnicBasket basket = new PicnicBasket();
+
+        basket.DropItem(new BeverageBottle(BeverageType.Wine));
+        basket.DropItem(new CheeseWedge());
+
+        solen.PackItem(basket);
+      }
+    }
+
+    public static bool CheckRedFriendship(Mobile m)
+    {
+      if (m is BaseCreature bc)
+      {
+        if (bc.Controlled && bc.ControlMaster is PlayerMobile)
+          return CheckRedFriendship(bc.ControlMaster);
+        if (bc.Summoned && bc.SummonMaster is PlayerMobile)
+          return CheckRedFriendship(bc.SummonMaster);
+      }
+
+      return m is PlayerMobile player && player.SolenFriendship == SolenFriendship.Red;
+    }
+
+    public static bool CheckBlackFriendship(Mobile m)
+    {
+      if (m is BaseCreature bc)
+      {
+        if (bc.Controlled && bc.ControlMaster is PlayerMobile)
+          return CheckBlackFriendship(bc.ControlMaster);
+        if (bc.Summoned && bc.SummonMaster is PlayerMobile)
+          return CheckBlackFriendship(bc.SummonMaster);
+      }
+
+      return m is PlayerMobile player && player.SolenFriendship == SolenFriendship.Black;
+    }
+
+    public static void OnRedDamage(Mobile from)
+    {
+      if (from is BaseCreature bc)
+      {
+        if (bc.Controlled && bc.ControlMaster is PlayerMobile)
+          OnRedDamage(bc.ControlMaster);
+        else if (bc.Summoned && bc.SummonMaster is PlayerMobile)
+          OnRedDamage(bc.SummonMaster);
+      }
+
+      if (from is PlayerMobile player && player.SolenFriendship == SolenFriendship.Red)
+      {
+        player.LocalOverheadMessage(MessageType.Regular, 0x3B2,
+          1054103); // The solen revoke their friendship. You will now be considered an intruder.
+
+        player.SolenFriendship = SolenFriendship.None;
+      }
+    }
+
+    public static void OnBlackDamage(Mobile from)
+    {
+      if (from is BaseCreature bc)
+      {
+        if (bc.Controlled && bc.ControlMaster is PlayerMobile)
+          OnBlackDamage(bc.ControlMaster);
+        else if (bc.Summoned && bc.SummonMaster is PlayerMobile)
+          OnBlackDamage(bc.SummonMaster);
+      }
+
+      if (from is PlayerMobile player && player.SolenFriendship == SolenFriendship.Black)
+      {
+        player.LocalOverheadMessage(MessageType.Regular, 0x3B2,
+          1054103); // The solen revoke their friendship. You will now be considered an intruder.
+
+        player.SolenFriendship = SolenFriendship.None;
+      }
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Arachnid/Magic/DreadSpider.cs

@@ -0,0 +1,76 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class DreadSpider : BaseCreature
+  {
+    [Constructible]
+    public DreadSpider() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 11;
+      BaseSoundID = 1170;
+
+      SetStr(196, 220);
+      SetDex(126, 145);
+      SetInt(286, 310);
+
+      SetHits(118, 132);
+
+      SetDamage(5, 17);
+
+      SetDamageType(ResistanceType.Physical, 20);
+      SetDamageType(ResistanceType.Poison, 80);
+
+      SetResistance(ResistanceType.Physical, 40, 50);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 20, 30);
+      SetResistance(ResistanceType.Poison, 90, 100);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.EvalInt, 65.1, 80.0);
+      SetSkill(SkillName.Magery, 65.1, 80.0);
+      SetSkill(SkillName.Meditation, 65.1, 80.0);
+      SetSkill(SkillName.MagicResist, 45.1, 60.0);
+      SetSkill(SkillName.Tactics, 55.1, 70.0);
+      SetSkill(SkillName.Wrestling, 60.1, 75.0);
+
+      Fame = 5000;
+      Karma = -5000;
+
+      VirtualArmor = 36;
+
+      PackItem(new SpidersSilk(8));
+    }
+
+    public DreadSpider(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a dread spider corpse";
+    public override string DefaultName => "a dread spider";
+
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override Poison HitPoison => Poison.Lethal;
+    public override int TreasureMapLevel => 3;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+    }
+
+    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();
+
+      if (BaseSoundID == 263)
+        BaseSoundID = 1170;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Arachnid/Magic/TerathanAvenger.cs

@@ -0,0 +1,76 @@
+namespace Server.Mobiles
+{
+  public class TerathanAvenger : BaseCreature
+  {
+    [Constructible]
+    public TerathanAvenger() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 152;
+      BaseSoundID = 0x24D;
+
+      SetStr(467, 645);
+      SetDex(77, 95);
+      SetInt(126, 150);
+
+      SetHits(296, 372);
+      SetMana(46, 70);
+
+      SetDamage(18, 22);
+
+      SetDamageType(ResistanceType.Physical, 50);
+      SetDamageType(ResistanceType.Poison, 50);
+
+      SetResistance(ResistanceType.Physical, 40, 50);
+      SetResistance(ResistanceType.Fire, 30, 40);
+      SetResistance(ResistanceType.Cold, 35, 45);
+      SetResistance(ResistanceType.Poison, 90, 100);
+      SetResistance(ResistanceType.Energy, 35, 45);
+
+      SetSkill(SkillName.EvalInt, 70.3, 100.0);
+      SetSkill(SkillName.Magery, 70.3, 100.0);
+      SetSkill(SkillName.Poisoning, 60.1, 80.0);
+      SetSkill(SkillName.MagicResist, 65.1, 80.0);
+      SetSkill(SkillName.Tactics, 90.1, 100.0);
+      SetSkill(SkillName.Wrestling, 90.1, 100.0);
+
+      Fame = 15000;
+      Karma = -15000;
+
+      VirtualArmor = 50;
+    }
+
+    public TerathanAvenger(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a terathan avenger corpse";
+    public override string DefaultName => "a terathan avenger";
+
+    public override Poison PoisonImmune => Poison.Deadly;
+    public override Poison HitPoison => Poison.Deadly;
+    public override int TreasureMapLevel => 3;
+    public override int Meat => 2;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.TerathansAndOphidians;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich, 2);
+    }
+
+    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();
+
+      if (BaseSoundID == 263)
+        BaseSoundID = 0x24D;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Arachnid/Magic/TerathanMatriarch.cs

@@ -0,0 +1,73 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class TerathanMatriarch : BaseCreature
+  {
+    [Constructible]
+    public TerathanMatriarch() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 72;
+      BaseSoundID = 599;
+
+      SetStr(316, 405);
+      SetDex(96, 115);
+      SetInt(366, 455);
+
+      SetHits(190, 243);
+
+      SetDamage(11, 14);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 30, 40);
+      SetResistance(ResistanceType.Cold, 35, 45);
+      SetResistance(ResistanceType.Poison, 40, 50);
+      SetResistance(ResistanceType.Energy, 35, 45);
+
+      SetSkill(SkillName.EvalInt, 90.1, 100.0);
+      SetSkill(SkillName.Magery, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 90.1, 100.0);
+      SetSkill(SkillName.Tactics, 50.1, 70.0);
+      SetSkill(SkillName.Wrestling, 60.1, 80.0);
+
+      Fame = 10000;
+      Karma = -10000;
+
+      PackItem(new SpidersSilk(5));
+      PackNecroReg(Utility.RandomMinMax(4, 10));
+    }
+
+    public TerathanMatriarch(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a terathan matriarch corpse";
+    public override string DefaultName => "a terathan matriarch";
+
+    public override int TreasureMapLevel => 4;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.TerathansAndOphidians;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Average, 2);
+      AddLoot(LootPack.MedScrolls, 2);
+      AddLoot(LootPack.Potions);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Arachnid/Melee/FrostSpider.cs

@@ -0,0 +1,78 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class FrostSpider : BaseCreature
+  {
+    [Constructible]
+    public FrostSpider() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 20;
+      BaseSoundID = 0x388;
+
+      SetStr(76, 100);
+      SetDex(126, 145);
+      SetInt(36, 60);
+
+      SetHits(46, 60);
+      SetMana(0);
+
+      SetDamage(6, 16);
+
+      SetDamageType(ResistanceType.Physical, 20);
+      SetDamageType(ResistanceType.Cold, 80);
+
+      SetResistance(ResistanceType.Physical, 25, 30);
+      SetResistance(ResistanceType.Fire, 5, 10);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 10, 20);
+
+      SetSkill(SkillName.MagicResist, 25.1, 40.0);
+      SetSkill(SkillName.Tactics, 35.1, 50.0);
+      SetSkill(SkillName.Wrestling, 50.1, 65.0);
+
+      Fame = 775;
+      Karma = -775;
+
+      VirtualArmor = 28;
+
+      Tamable = true;
+      ControlSlots = 1;
+      MinTameSkill = 74.7;
+
+      PackItem(new SpidersSilk(7));
+    }
+
+    public FrostSpider(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a frost spider corpse";
+    public override string DefaultName => "a frost spider";
+
+    public override FoodType FavoriteFood => FoodType.Meat;
+    public override PackInstinct PackInstinct => PackInstinct.Arachnid;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+      AddLoot(LootPack.Poor);
+    }
+
+    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();
+
+      if (BaseSoundID == 387)
+        BaseSoundID = 0x388;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Arachnid/Melee/GiantBlackWidow.cs

@@ -0,0 +1,73 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class GiantBlackWidow : BaseCreature
+  {
+    [Constructible]
+    public GiantBlackWidow() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0x9D;
+      BaseSoundID = 0x388; // TODO: validate
+
+      SetStr(76, 100);
+      SetDex(96, 115);
+      SetInt(36, 60);
+
+      SetHits(46, 60);
+
+      SetDamage(5, 17);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 20, 30);
+      SetResistance(ResistanceType.Fire, 10, 20);
+      SetResistance(ResistanceType.Cold, 10, 20);
+      SetResistance(ResistanceType.Poison, 50, 60);
+      SetResistance(ResistanceType.Energy, 10, 20);
+
+      SetSkill(SkillName.Anatomy, 30.3, 75.0);
+      SetSkill(SkillName.Poisoning, 60.1, 80.0);
+      SetSkill(SkillName.MagicResist, 45.1, 60.0);
+      SetSkill(SkillName.Tactics, 65.1, 80.0);
+      SetSkill(SkillName.Wrestling, 70.1, 85.0);
+
+      Fame = 3500;
+      Karma = -3500;
+
+      VirtualArmor = 24;
+
+      PackItem(new SpidersSilk(5));
+      PackItem(new LesserPoisonPotion());
+      PackItem(new LesserPoisonPotion());
+    }
+
+    public GiantBlackWidow(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a giant black widow spider corpse";
+    public override string DefaultName => "a giant black wide";
+
+    public override FoodType FavoriteFood => FoodType.Meat;
+    public override Poison PoisonImmune => Poison.Deadly;
+    public override Poison HitPoison => Poison.Deadly;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Arachnid/Melee/GiantSpider.cs

@@ -0,0 +1,73 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class GiantSpider : BaseCreature
+  {
+    [Constructible]
+    public GiantSpider() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 28;
+      BaseSoundID = 0x388;
+
+      SetStr(76, 100);
+      SetDex(76, 95);
+      SetInt(36, 60);
+
+      SetHits(46, 60);
+      SetMana(0);
+
+      SetDamage(5, 13);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 15, 20);
+      SetResistance(ResistanceType.Poison, 25, 35);
+
+      SetSkill(SkillName.Poisoning, 60.1, 80.0);
+      SetSkill(SkillName.MagicResist, 25.1, 40.0);
+      SetSkill(SkillName.Tactics, 35.1, 50.0);
+      SetSkill(SkillName.Wrestling, 50.1, 65.0);
+
+      Fame = 600;
+      Karma = -600;
+
+      VirtualArmor = 16;
+
+      Tamable = true;
+      ControlSlots = 1;
+      MinTameSkill = 59.1;
+
+      PackItem(new SpidersSilk(5));
+    }
+
+    public GiantSpider(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a giant spider corpse";
+    public override string DefaultName => "a giant spider";
+
+    public override FoodType FavoriteFood => FoodType.Meat;
+    public override PackInstinct PackInstinct => PackInstinct.Arachnid;
+    public override Poison PoisonImmune => Poison.Regular;
+    public override Poison HitPoison => Poison.Regular;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Poor);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Arachnid/Melee/TerathanDrone.cs

@@ -0,0 +1,75 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class TerathanDrone : BaseCreature
+  {
+    [Constructible]
+    public TerathanDrone() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 71;
+      BaseSoundID = 594;
+
+      SetStr(36, 65);
+      SetDex(96, 145);
+      SetInt(21, 45);
+
+      SetHits(22, 39);
+      SetMana(0);
+
+      SetDamage(6, 12);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 20, 25);
+      SetResistance(ResistanceType.Fire, 10, 20);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 15, 25);
+
+      SetSkill(SkillName.Poisoning, 40.1, 60.0);
+      SetSkill(SkillName.MagicResist, 30.1, 45.0);
+      SetSkill(SkillName.Tactics, 30.1, 50.0);
+      SetSkill(SkillName.Wrestling, 40.1, 50.0);
+
+      Fame = 2000;
+      Karma = -2000;
+
+      VirtualArmor = 24;
+
+      PackItem(new SpidersSilk(2));
+    }
+
+    public TerathanDrone(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a terathan drone corpse";
+    public override string DefaultName => "a terathan drone";
+
+    public override int Meat => 4;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.TerathansAndOphidians;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+      // TODO: weapon?
+    }
+
+    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();
+
+      if (BaseSoundID == 589)
+        BaseSoundID = 594;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Arachnid/Melee/TerathanWarrior.cs

@@ -0,0 +1,73 @@
+using Server.Engines.Plants;
+
+namespace Server.Mobiles
+{
+  public class TerathanWarrior : BaseCreature
+  {
+    [Constructible]
+    public TerathanWarrior() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 70;
+      BaseSoundID = 589;
+
+      SetStr(166, 215);
+      SetDex(96, 145);
+      SetInt(41, 65);
+
+      SetHits(100, 129);
+      SetMana(0);
+
+      SetDamage(7, 17);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 30, 35);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 25, 35);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 25, 35);
+
+      SetSkill(SkillName.Poisoning, 60.1, 80.0);
+      SetSkill(SkillName.MagicResist, 60.1, 75.0);
+      SetSkill(SkillName.Tactics, 80.1, 100.0);
+      SetSkill(SkillName.Wrestling, 80.1, 90.0);
+
+      Fame = 4000;
+      Karma = -4000;
+
+      VirtualArmor = 30;
+
+      if (Core.ML && Utility.RandomDouble() < .33)
+        PackItem(Seed.RandomPeculiarSeed(3));
+    }
+
+    public TerathanWarrior(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a terathan warrior corpse";
+    public override string DefaultName => "a terathan warrior";
+
+    public override int TreasureMapLevel => 1;
+    public override int Meat => 4;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.TerathansAndOphidians;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Elemental/Magic/AcidElemental.cs

@@ -0,0 +1,84 @@
+namespace Server.Mobiles
+{
+  [TypeAlias("Server.Mobiles.ToxicElemental")]
+  public class AcidElemental : BaseCreature
+  {
+    [Constructible]
+    public AcidElemental() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0x9E;
+      BaseSoundID = 278;
+
+      SetStr(326, 355);
+      SetDex(66, 85);
+      SetInt(271, 295);
+
+      SetHits(196, 213);
+
+      SetDamage(9, 15);
+
+      SetDamageType(ResistanceType.Physical, 25);
+      SetDamageType(ResistanceType.Fire, 50);
+      SetDamageType(ResistanceType.Energy, 25);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 40, 50);
+      SetResistance(ResistanceType.Cold, 20, 30);
+      SetResistance(ResistanceType.Poison, 10, 20);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.Anatomy, 30.3, 60.0);
+      SetSkill(SkillName.EvalInt, 70.1, 85.0);
+      SetSkill(SkillName.Magery, 70.1, 85.0);
+      SetSkill(SkillName.MagicResist, 60.1, 75.0);
+      SetSkill(SkillName.Tactics, 80.1, 90.0);
+      SetSkill(SkillName.Wrestling, 70.1, 90.0);
+
+      Fame = 10000;
+      Karma = -10000;
+
+      VirtualArmor = 40;
+    }
+
+    public AcidElemental(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an acid elemental corpse";
+    public override string DefaultName => "an acid elemental";
+
+    public override bool BleedImmune => true;
+    public override Poison HitPoison => Poison.Lethal;
+    public override double HitPoisonChance => 0.6;
+
+    public override int TreasureMapLevel => Core.AOS ? 2 : 3;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Average);
+    }
+
+    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();
+
+      if (BaseSoundID == 263)
+        BaseSoundID = 278;
+
+      if (Body == 13)
+        Body = 0x9E;
+
+      if (Hue == 0x4001)
+        Hue = 0;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Elemental/Magic/AirElemental.cs

@@ -0,0 +1,79 @@
+namespace Server.Mobiles
+{
+  public class AirElemental : BaseCreature
+  {
+    [Constructible]
+    public AirElemental() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 13;
+      Hue = 0x4001;
+      BaseSoundID = 655;
+
+      SetStr(126, 155);
+      SetDex(166, 185);
+      SetInt(101, 125);
+
+      SetHits(76, 93);
+
+      SetDamage(8, 10);
+
+      SetDamageType(ResistanceType.Physical, 20);
+      SetDamageType(ResistanceType.Cold, 40);
+      SetDamageType(ResistanceType.Energy, 40);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 15, 25);
+      SetResistance(ResistanceType.Cold, 10, 20);
+      SetResistance(ResistanceType.Poison, 10, 20);
+      SetResistance(ResistanceType.Energy, 25, 35);
+
+      SetSkill(SkillName.EvalInt, 60.1, 75.0);
+      SetSkill(SkillName.Magery, 60.1, 75.0);
+      SetSkill(SkillName.MagicResist, 60.1, 75.0);
+      SetSkill(SkillName.Tactics, 60.1, 80.0);
+      SetSkill(SkillName.Wrestling, 60.1, 80.0);
+
+      Fame = 4500;
+      Karma = -4500;
+
+      VirtualArmor = 40;
+      ControlSlots = 2;
+    }
+
+    public AirElemental(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an air elemental corpse";
+    public override double DispelDifficulty => 117.5;
+    public override double DispelFocus => 45.0;
+
+    public override string DefaultName => "an air elemental";
+
+    public override bool BleedImmune => true;
+    public override int TreasureMapLevel => 2;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Meager);
+      AddLoot(LootPack.LowScrolls);
+      AddLoot(LootPack.MedScrolls);
+    }
+
+    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();
+
+      if (BaseSoundID == 263)
+        BaseSoundID = 655;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Elemental/Magic/BloodElemental.cs

@@ -0,0 +1,69 @@
+namespace Server.Mobiles
+{
+  public class BloodElemental : BaseCreature
+  {
+    [Constructible]
+    public BloodElemental() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 159;
+      BaseSoundID = 278;
+
+      SetStr(526, 615);
+      SetDex(66, 85);
+      SetInt(226, 350);
+
+      SetHits(316, 369);
+
+      SetDamage(17, 27);
+
+      SetDamageType(ResistanceType.Physical, 0);
+      SetDamageType(ResistanceType.Poison, 50);
+      SetDamageType(ResistanceType.Energy, 50);
+
+      SetResistance(ResistanceType.Physical, 55, 65);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 50, 60);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.EvalInt, 85.1, 100.0);
+      SetSkill(SkillName.Magery, 85.1, 100.0);
+      SetSkill(SkillName.Meditation, 10.4, 50.0);
+      SetSkill(SkillName.MagicResist, 80.1, 95.0);
+      SetSkill(SkillName.Tactics, 80.1, 100.0);
+      SetSkill(SkillName.Wrestling, 80.1, 100.0);
+
+      Fame = 12500;
+      Karma = -12500;
+
+      VirtualArmor = 60;
+    }
+
+    public BloodElemental(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a blood elemental corpse";
+    public override string DefaultName => "a blood elemental";
+
+    public override int TreasureMapLevel => 5;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+      AddLoot(LootPack.Rich);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Elemental/Magic/Efreet.cs

@@ -0,0 +1,90 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Efreet : BaseCreature
+  {
+    [Constructible]
+    public Efreet() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 131;
+      BaseSoundID = 768;
+
+      SetStr(326, 355);
+      SetDex(266, 285);
+      SetInt(171, 195);
+
+      SetHits(196, 213);
+
+      SetDamage(11, 13);
+
+      SetDamageType(ResistanceType.Physical, 0);
+      SetDamageType(ResistanceType.Fire, 50);
+      SetDamageType(ResistanceType.Energy, 50);
+
+      SetResistance(ResistanceType.Physical, 50, 60);
+      SetResistance(ResistanceType.Fire, 60, 70);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.EvalInt, 60.1, 75.0);
+      SetSkill(SkillName.Magery, 60.1, 75.0);
+      SetSkill(SkillName.MagicResist, 60.1, 75.0);
+      SetSkill(SkillName.Tactics, 60.1, 80.0);
+      SetSkill(SkillName.Wrestling, 60.1, 80.0);
+
+      Fame = 10000;
+      Karma = -10000;
+
+      VirtualArmor = 56;
+    }
+
+    public Efreet(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an efreet corpse";
+    public override string DefaultName => "an efreet";
+
+    public override int TreasureMapLevel => Core.AOS ? 4 : 5;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Gems);
+
+      if (0.02 > Utility.RandomDouble())
+        switch (Utility.Random(5))
+        {
+          case 0:
+            PackItem(new DaemonArms());
+            break;
+          case 1:
+            PackItem(new DaemonChest());
+            break;
+          case 2:
+            PackItem(new DaemonGloves());
+            break;
+          case 3:
+            PackItem(new DaemonLegs());
+            break;
+          case 4:
+            PackItem(new DaemonHelm());
+            break;
+        }
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Elemental/Magic/FireElemental.cs

@@ -0,0 +1,82 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class FireElemental : BaseCreature
+  {
+    [Constructible]
+    public FireElemental() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 15;
+      BaseSoundID = 838;
+
+      SetStr(126, 155);
+      SetDex(166, 185);
+      SetInt(101, 125);
+
+      SetHits(76, 93);
+
+      SetDamage(7, 9);
+
+      SetDamageType(ResistanceType.Physical, 25);
+      SetDamageType(ResistanceType.Fire, 75);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 60, 80);
+      SetResistance(ResistanceType.Cold, 5, 10);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.EvalInt, 60.1, 75.0);
+      SetSkill(SkillName.Magery, 60.1, 75.0);
+      SetSkill(SkillName.MagicResist, 75.2, 105.0);
+      SetSkill(SkillName.Tactics, 80.1, 100.0);
+      SetSkill(SkillName.Wrestling, 70.1, 100.0);
+
+      Fame = 4500;
+      Karma = -4500;
+
+      VirtualArmor = 40;
+      ControlSlots = 4;
+
+      PackItem(new SulfurousAsh(3));
+
+      AddItem(new LightSource());
+    }
+
+    public FireElemental(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a fire elemental corpse";
+    public override double DispelDifficulty => 117.5;
+    public override double DispelFocus => 45.0;
+
+    public override string DefaultName => "a fire elemental";
+
+    public override bool BleedImmune => true;
+    public override int TreasureMapLevel => 2;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Meager);
+      AddLoot(LootPack.Gems);
+    }
+
+    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();
+
+      if (BaseSoundID == 274)
+        BaseSoundID = 838;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Elemental/Magic/IceElemental.cs

@@ -0,0 +1,71 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class IceElemental : BaseCreature
+  {
+    [Constructible]
+    public IceElemental() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 161;
+      BaseSoundID = 268;
+
+      SetStr(156, 185);
+      SetDex(96, 115);
+      SetInt(171, 192);
+
+      SetHits(94, 111);
+
+      SetDamage(10, 21);
+
+      SetDamageType(ResistanceType.Physical, 25);
+      SetDamageType(ResistanceType.Cold, 75);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 5, 10);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.EvalInt, 10.5, 60.0);
+      SetSkill(SkillName.Magery, 10.5, 60.0);
+      SetSkill(SkillName.MagicResist, 30.1, 80.0);
+      SetSkill(SkillName.Tactics, 70.1, 100.0);
+      SetSkill(SkillName.Wrestling, 60.1, 100.0);
+
+      Fame = 4000;
+      Karma = -4000;
+
+      VirtualArmor = 40;
+
+      PackItem(new BlackPearl());
+      PackReg(3);
+    }
+
+    public IceElemental(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an ice elemental corpse";
+    public override string DefaultName => "an ice elemental";
+    public override bool BleedImmune => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average, 2);
+      AddLoot(LootPack.Gems, 2);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Elemental/Magic/PoisonElemental.cs

@@ -0,0 +1,81 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class PoisonElemental : BaseCreature
+  {
+    [Constructible]
+    public PoisonElemental() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 162;
+      BaseSoundID = 263;
+
+      SetStr(426, 515);
+      SetDex(166, 185);
+      SetInt(361, 435);
+
+      SetHits(256, 309);
+
+      SetDamage(12, 18);
+
+      SetDamageType(ResistanceType.Physical, 10);
+      SetDamageType(ResistanceType.Poison, 90);
+
+      SetResistance(ResistanceType.Physical, 60, 70);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 20, 30);
+      SetResistance(ResistanceType.Poison, 100);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.EvalInt, 80.1, 95.0);
+      SetSkill(SkillName.Magery, 80.1, 95.0);
+      SetSkill(SkillName.Meditation, 80.2, 120.0);
+      SetSkill(SkillName.Poisoning, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 85.2, 115.0);
+      SetSkill(SkillName.Tactics, 80.1, 100.0);
+      SetSkill(SkillName.Wrestling, 70.1, 90.0);
+
+      Fame = 12500;
+      Karma = -12500;
+
+      VirtualArmor = 70;
+
+      PackItem(new Nightshade(4));
+      PackItem(new LesserPoisonPotion());
+    }
+
+    public PoisonElemental(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a poison elementals corpse";
+    public override string DefaultName => "a poison elemental";
+
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override Poison HitPoison => Poison.Lethal;
+    public override double HitPoisonChance => 0.75;
+
+    public override int TreasureMapLevel => 5;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.MedScrolls);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Elemental/Magic/WaterElemental.cs

@@ -0,0 +1,77 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class WaterElemental : BaseCreature
+  {
+    [Constructible]
+    public WaterElemental() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 16;
+      BaseSoundID = 278;
+
+      SetStr(126, 155);
+      SetDex(66, 85);
+      SetInt(101, 125);
+
+      SetHits(76, 93);
+
+      SetDamage(7, 9);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 10, 25);
+      SetResistance(ResistanceType.Cold, 10, 25);
+      SetResistance(ResistanceType.Poison, 60, 70);
+      SetResistance(ResistanceType.Energy, 5, 10);
+
+      SetSkill(SkillName.EvalInt, 60.1, 75.0);
+      SetSkill(SkillName.Magery, 60.1, 75.0);
+      SetSkill(SkillName.MagicResist, 100.1, 115.0);
+      SetSkill(SkillName.Tactics, 50.1, 70.0);
+      SetSkill(SkillName.Wrestling, 50.1, 70.0);
+
+      Fame = 4500;
+      Karma = -4500;
+
+      VirtualArmor = 40;
+      ControlSlots = 3;
+      CanSwim = true;
+
+      PackItem(new BlackPearl(3));
+    }
+
+    public WaterElemental(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a water elemental corpse";
+    public override double DispelDifficulty => 117.5;
+    public override double DispelFocus => 45.0;
+
+    public override string DefaultName => "a water elemental";
+
+    public override bool BleedImmune => true;
+    public override int TreasureMapLevel => 2;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Meager);
+      AddLoot(LootPack.Potions);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Elemental/Melee/EarthElemental.cs

@@ -0,0 +1,79 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class EarthElemental : BaseCreature
+  {
+    [Constructible]
+    public EarthElemental() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 14;
+      BaseSoundID = 268;
+
+      SetStr(126, 155);
+      SetDex(66, 85);
+      SetInt(71, 92);
+
+      SetHits(76, 93);
+
+      SetDamage(9, 16);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 30, 35);
+      SetResistance(ResistanceType.Fire, 10, 20);
+      SetResistance(ResistanceType.Cold, 10, 20);
+      SetResistance(ResistanceType.Poison, 15, 25);
+      SetResistance(ResistanceType.Energy, 15, 25);
+
+      SetSkill(SkillName.MagicResist, 50.1, 95.0);
+      SetSkill(SkillName.Tactics, 60.1, 100.0);
+      SetSkill(SkillName.Wrestling, 60.1, 100.0);
+
+      Fame = 3500;
+      Karma = -3500;
+
+      VirtualArmor = 34;
+      ControlSlots = 2;
+
+      PackItem(new FertileDirt(Utility.RandomMinMax(1, 4)));
+      PackItem(new MandrakeRoot());
+
+      Item ore = new IronOre(5);
+      ore.ItemID = 0x19B7;
+      PackItem(ore);
+    }
+
+    public EarthElemental(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an earth elemental corpse";
+    public override double DispelDifficulty => 117.5;
+    public override double DispelFocus => 45.0;
+
+    public override string DefaultName => "an earth elemental";
+
+    public override bool BleedImmune => true;
+    public override int TreasureMapLevel => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Meager);
+      AddLoot(LootPack.Gems);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Elemental/Melee/SnowElemental.cs

@@ -0,0 +1,73 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class SnowElemental : BaseCreature
+  {
+    [Constructible]
+    public SnowElemental() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 163;
+      BaseSoundID = 263;
+
+      SetStr(326, 355);
+      SetDex(166, 185);
+      SetInt(71, 95);
+
+      SetHits(196, 213);
+
+      SetDamage(11, 17);
+
+      SetDamageType(ResistanceType.Physical, 20);
+      SetDamageType(ResistanceType.Cold, 80);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 10, 15);
+      SetResistance(ResistanceType.Cold, 60, 70);
+      SetResistance(ResistanceType.Poison, 25, 35);
+      SetResistance(ResistanceType.Energy, 25, 35);
+
+      SetSkill(SkillName.MagicResist, 50.1, 65.0);
+      SetSkill(SkillName.Tactics, 80.1, 100.0);
+      SetSkill(SkillName.Wrestling, 80.1, 100.0);
+
+      Fame = 5000;
+      Karma = -5000;
+
+      VirtualArmor = 50;
+
+      PackItem(new BlackPearl(3));
+      Item ore = new IronOre(3);
+      ore.ItemID = 0x19B8;
+      PackItem(ore);
+    }
+
+    public SnowElemental(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a snow elemental corpse";
+    public override string DefaultName => "a snow elemental";
+
+    public override bool BleedImmune => true;
+
+    public override int TreasureMapLevel => Utility.RandomList(2, 3);
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/AncientLich.cs

@@ -0,0 +1,103 @@
+namespace Server.Mobiles
+{
+  public class AncientLich : BaseCreature
+  {
+    [Constructible]
+    public AncientLich() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("ancient lich");
+      Body = 78;
+      BaseSoundID = 412;
+
+      SetStr(216, 305);
+      SetDex(96, 115);
+      SetInt(966, 1045);
+
+      SetHits(560, 595);
+
+      SetDamage(15, 27);
+
+      SetDamageType(ResistanceType.Physical, 20);
+      SetDamageType(ResistanceType.Cold, 40);
+      SetDamageType(ResistanceType.Energy, 40);
+
+      SetResistance(ResistanceType.Physical, 55, 65);
+      SetResistance(ResistanceType.Fire, 25, 30);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 50, 60);
+      SetResistance(ResistanceType.Energy, 25, 30);
+
+      SetSkill(SkillName.EvalInt, 120.1, 130.0);
+      SetSkill(SkillName.Magery, 120.1, 130.0);
+      SetSkill(SkillName.Meditation, 100.1, 101.0);
+      SetSkill(SkillName.Poisoning, 100.1, 101.0);
+      SetSkill(SkillName.MagicResist, 175.2, 200.0);
+      SetSkill(SkillName.Tactics, 90.1, 100.0);
+      SetSkill(SkillName.Wrestling, 75.1, 100.0);
+      SetSkill(SkillName.Necromancy, 120.1, 130.0);
+      SetSkill(SkillName.SpiritSpeak, 120.1, 130.0);
+
+      Fame = 23000;
+      Karma = -23000;
+
+      VirtualArmor = 60;
+      PackNecroReg(30, 275);
+    }
+
+    public AncientLich(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an ancient lich's corpse";
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override bool Unprovokable => true;
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override int TreasureMapLevel => 5;
+
+    public override int GetIdleSound()
+    {
+      return 0x19D;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x175;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x108;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0xE2;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x28B;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich, 3);
+      AddLoot(LootPack.MedScrolls, 2);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/ArcaneDaemon.cs

@@ -0,0 +1,75 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class ArcaneDaemon : BaseCreature
+  {
+    [Constructible]
+    public ArcaneDaemon() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0x310;
+      BaseSoundID = 0x47D;
+
+      SetStr(131, 150);
+      SetDex(126, 145);
+      SetInt(301, 350);
+
+      SetHits(101, 115);
+
+      SetDamage(12, 16);
+
+      SetDamageType(ResistanceType.Physical, 80);
+      SetDamageType(ResistanceType.Fire, 20);
+
+      SetResistance(ResistanceType.Physical, 50, 60);
+      SetResistance(ResistanceType.Fire, 70, 80);
+      SetResistance(ResistanceType.Cold, 10, 20);
+      SetResistance(ResistanceType.Poison, 50, 60);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.MagicResist, 85.1, 95.0);
+      SetSkill(SkillName.Tactics, 70.1, 80.0);
+      SetSkill(SkillName.Wrestling, 60.1, 80.0);
+      SetSkill(SkillName.Magery, 80.1, 90.0);
+      SetSkill(SkillName.EvalInt, 70.1, 80.0);
+      SetSkill(SkillName.Meditation, 70.1, 80.0);
+
+      Fame = 7000;
+      Karma = -10000;
+
+      VirtualArmor = 55;
+    }
+
+    public ArcaneDaemon(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an arcane daemon corpse";
+
+    public override string DefaultName => "an arcane daemon";
+
+    public override Poison PoisonImmune => Poison.Deadly;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return WeaponAbility.ConcussionBlow;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average, 2);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Balron.cs

@@ -0,0 +1,78 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Balron : BaseCreature
+  {
+    [Constructible]
+    public Balron() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("balron");
+      Body = 40;
+      BaseSoundID = 357;
+
+      SetStr(986, 1185);
+      SetDex(177, 255);
+      SetInt(151, 250);
+
+      SetHits(592, 711);
+
+      SetDamage(22, 29);
+
+      SetDamageType(ResistanceType.Physical, 50);
+      SetDamageType(ResistanceType.Fire, 25);
+      SetDamageType(ResistanceType.Energy, 25);
+
+      SetResistance(ResistanceType.Physical, 65, 80);
+      SetResistance(ResistanceType.Fire, 60, 80);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 100);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.Anatomy, 25.1, 50.0);
+      SetSkill(SkillName.EvalInt, 90.1, 100.0);
+      SetSkill(SkillName.Magery, 95.5, 100.0);
+      SetSkill(SkillName.Meditation, 25.1, 50.0);
+      SetSkill(SkillName.MagicResist, 100.5, 150.0);
+      SetSkill(SkillName.Tactics, 90.1, 100.0);
+      SetSkill(SkillName.Wrestling, 90.1, 100.0);
+
+      Fame = 24000;
+      Karma = -24000;
+
+      VirtualArmor = 90;
+
+      PackItem(new Longsword());
+    }
+
+    public Balron(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a balron corpse";
+
+    public override bool CanRummageCorpses => true;
+    public override Poison PoisonImmune => Poison.Deadly;
+    public override int TreasureMapLevel => 5;
+    public override int Meat => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich, 2);
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.MedScrolls, 2);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Betrayer.cs

@@ -0,0 +1,179 @@
+using System;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Mobiles
+{
+  public class Betrayer : BaseCreature
+  {
+    private DateTime m_NextAbilityTime;
+    private bool m_Stunning;
+
+    [Constructible]
+    public Betrayer() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 767;
+
+      SetStr(401, 500);
+      SetDex(81, 100);
+      SetInt(151, 200);
+
+      SetHits(241, 300);
+
+      SetDamage(16, 22);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 60, 70);
+      SetResistance(ResistanceType.Fire, 60, 70);
+      SetResistance(ResistanceType.Cold, 60, 70);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.Anatomy, 90.1, 100.0);
+      SetSkill(SkillName.EvalInt, 90.1, 100.0);
+      SetSkill(SkillName.Magery, 50.1, 100.0);
+      SetSkill(SkillName.Meditation, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 120.1, 130.0);
+      SetSkill(SkillName.Tactics, 90.1, 100.0);
+      SetSkill(SkillName.Wrestling, 90.1, 100.0);
+
+      Fame = 15000;
+      Karma = -15000;
+
+      VirtualArmor = 65;
+      SpeechHue = Utility.RandomDyedHue();
+
+      PackItem(new PowerCrystal());
+
+      if (0.02 > Utility.RandomDouble())
+        PackItem(new BlackthornWelcomeBook());
+
+      m_NextAbilityTime = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(5, 30));
+    }
+
+    public Betrayer(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a betrayer corpse";
+
+    public override string DefaultName => "a betrayer";
+
+    public override bool AlwaysMurderer => true;
+    public override bool BardImmune => !Core.AOS;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override int Meat => 1;
+    public override int TreasureMapLevel => 5;
+
+    public override void OnDeath(Container c)
+    {
+      base.OnDeath(c);
+
+      if (0.05 > Utility.RandomDouble())
+      {
+        if (!IsParagon)
+        {
+          if (0.75 > Utility.RandomDouble())
+            c.DropItem(DawnsMusicGear.RandomCommon);
+          else
+            c.DropItem(DawnsMusicGear.RandomUncommon);
+        }
+        else
+        {
+          c.DropItem(DawnsMusicGear.RandomRare);
+        }
+      }
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x423;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x23B;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x140;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Gems, 1);
+    }
+
+    public override void OnGaveMeleeAttack(Mobile defender)
+    {
+      base.OnGaveMeleeAttack(defender);
+
+      if (!m_Stunning && 0.3 > Utility.RandomDouble())
+      {
+        m_Stunning = true;
+
+        defender.Animate(21, 6, 1, true, false, 0);
+        PlaySound(0xEE);
+        defender.LocalOverheadMessage(MessageType.Regular, 0x3B2, false,
+          "You have been stunned by a colossal blow!");
+
+        if (Weapon is BaseWeapon weapon)
+          weapon.OnHit(this, defender);
+
+        if (defender.Alive)
+        {
+          defender.Frozen = true;
+          Timer.DelayCall(TimeSpan.FromSeconds(5.0), Recover_Callback, defender);
+        }
+      }
+    }
+
+    private void Recover_Callback(Mobile defender)
+    {
+      defender.Frozen = false;
+      defender.Combatant = null;
+      defender.LocalOverheadMessage(MessageType.Regular, 0x3B2, false, "You recover your senses.");
+      m_Stunning = false;
+    }
+
+    public override void OnActionCombat()
+    {
+      Mobile combatant = Combatant;
+
+      if (DateTime.UtcNow < m_NextAbilityTime || combatant?.Deleted != false || combatant.Map != Map ||
+          !InRange(combatant, 3) || !CanBeHarmful(combatant) || !InLOS(combatant))
+        return;
+
+      m_NextAbilityTime = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(5, 30));
+
+      if (Utility.RandomBool())
+      {
+        FixedParticles(0x376A, 9, 32, 0x2539, EffectLayer.LeftHand);
+        PlaySound(0x1DE);
+
+        foreach (Mobile m in GetMobilesInRange(2))
+          if (m != this && IsEnemy(m))
+            m.ApplyPoison(this, Poison.Deadly);
+      }
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Bogle.cs

@@ -0,0 +1,64 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Bogle : BaseCreature
+  {
+    [Constructible]
+    public Bogle() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 153;
+      BaseSoundID = 0x482;
+
+      SetStr(76, 100);
+      SetDex(76, 95);
+      SetInt(36, 60);
+
+      SetHits(46, 60);
+
+      SetDamage(7, 11);
+
+      SetSkill(SkillName.EvalInt, 55.1, 70.0);
+      SetSkill(SkillName.Magery, 55.1, 70.0);
+      SetSkill(SkillName.MagicResist, 55.1, 70.0);
+      SetSkill(SkillName.Tactics, 45.1, 60.0);
+      SetSkill(SkillName.Wrestling, 45.1, 55.0);
+
+      Fame = 4000;
+      Karma = -4000;
+
+      VirtualArmor = 28;
+      PackItem(Loot.RandomWeapon());
+      PackItem(new Bone());
+    }
+
+    public Bogle(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a ghostly corpse";
+    public override string DefaultName => "a bogle";
+
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/BoneMagi.cs

@@ -0,0 +1,80 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  [TypeAlias("Server.Mobiles.BoneMage")]
+  public class BoneMagi : BaseCreature
+  {
+    [Constructible]
+    public BoneMagi() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 148;
+      BaseSoundID = 451;
+
+      SetStr(76, 100);
+      SetDex(56, 75);
+      SetInt(186, 210);
+
+      SetHits(46, 60);
+
+      SetDamage(3, 7);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 35, 40);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.EvalInt, 60.1, 70.0);
+      SetSkill(SkillName.Magery, 60.1, 70.0);
+      SetSkill(SkillName.MagicResist, 55.1, 70.0);
+      SetSkill(SkillName.Tactics, 45.1, 60.0);
+      SetSkill(SkillName.Wrestling, 45.1, 55.0);
+      SetSkill(SkillName.Necromancy, 89, 99.1);
+      SetSkill(SkillName.SpiritSpeak, 90.0, 99.0);
+
+      Fame = 3000;
+      Karma = -3000;
+
+      VirtualArmor = 38;
+
+      PackReg(3);
+      PackNecroReg(3, 10);
+      PackItem(new Bone());
+    }
+
+    public BoneMagi(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a skeletal corpse";
+    public override string DefaultName => "a bone mage";
+
+    public override bool BleedImmune => true;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override Poison PoisonImmune => Poison.Regular;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.LowScrolls);
+      AddLoot(LootPack.Potions);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Daemon.cs

@@ -0,0 +1,80 @@
+using Server.Ethics;
+using Server.Factions;
+
+namespace Server.Mobiles
+{
+  public class Daemon : BaseCreature
+  {
+    [Constructible]
+    public Daemon() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("daemon");
+      Body = 9;
+      BaseSoundID = 357;
+
+      SetStr(476, 505);
+      SetDex(76, 95);
+      SetInt(301, 325);
+
+      SetHits(286, 303);
+
+      SetDamage(7, 14);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 45, 60);
+      SetResistance(ResistanceType.Fire, 50, 60);
+      SetResistance(ResistanceType.Cold, 30, 40);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.EvalInt, 70.1, 80.0);
+      SetSkill(SkillName.Magery, 70.1, 80.0);
+      SetSkill(SkillName.MagicResist, 85.1, 95.0);
+      SetSkill(SkillName.Tactics, 70.1, 80.0);
+      SetSkill(SkillName.Wrestling, 60.1, 80.0);
+
+      Fame = 15000;
+      Karma = -15000;
+
+      VirtualArmor = 58;
+      ControlSlots = Core.SE ? 4 : 5;
+    }
+
+    public Daemon(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a daemon corpse";
+    public override double DispelDifficulty => 125.0;
+    public override double DispelFocus => 45.0;
+
+    public override Faction FactionAllegiance => Shadowlords.Instance;
+    public override Ethic EthicAllegiance => Ethic.Evil;
+
+    public override bool CanRummageCorpses => true;
+    public override Poison PoisonImmune => Poison.Regular;
+    public override int TreasureMapLevel => 4;
+    public override int Meat => 1;
+    public override bool CanFly => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Average, 2);
+      AddLoot(LootPack.MedScrolls, 2);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/ElderGazer.cs

@@ -0,0 +1,67 @@
+namespace Server.Mobiles
+{
+  public class ElderGazer : BaseCreature
+  {
+    [Constructible]
+    public ElderGazer() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 22;
+      BaseSoundID = 377;
+
+      SetStr(296, 325);
+      SetDex(86, 105);
+      SetInt(291, 385);
+
+      SetHits(178, 195);
+
+      SetDamage(8, 19);
+
+      SetDamageType(ResistanceType.Physical, 50);
+      SetDamageType(ResistanceType.Energy, 50);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 60, 70);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 40, 50);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.Anatomy, 62.0, 100.0);
+      SetSkill(SkillName.EvalInt, 90.1, 100.0);
+      SetSkill(SkillName.Magery, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 115.1, 130.0);
+      SetSkill(SkillName.Tactics, 80.1, 100.0);
+      SetSkill(SkillName.Wrestling, 80.1, 100.0);
+
+      Fame = 12500;
+      Karma = -12500;
+
+      VirtualArmor = 50;
+    }
+
+    public ElderGazer(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an elder gazer corpse";
+    public override string DefaultName => "an elder gazer";
+
+    public override int TreasureMapLevel => Core.AOS ? 4 : 0;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/EvilMage.cs

@@ -0,0 +1,73 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class EvilMage : BaseCreature
+  {
+    [Constructible]
+    public EvilMage() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("evil mage");
+      Title = "the evil mage";
+      Body = 124;
+
+      SetStr(81, 105);
+      SetDex(91, 115);
+      SetInt(96, 120);
+
+      SetHits(49, 63);
+
+      SetDamage(5, 10);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 15, 20);
+      SetResistance(ResistanceType.Fire, 5, 10);
+      SetResistance(ResistanceType.Poison, 5, 10);
+      SetResistance(ResistanceType.Energy, 5, 10);
+
+      SetSkill(SkillName.EvalInt, 75.1, 100.0);
+      SetSkill(SkillName.Magery, 75.1, 100.0);
+      SetSkill(SkillName.MagicResist, 75.0, 97.5);
+      SetSkill(SkillName.Tactics, 65.0, 87.5);
+      SetSkill(SkillName.Wrestling, 20.2, 60.0);
+
+      Fame = 2500;
+      Karma = -2500;
+
+      VirtualArmor = 16;
+      PackReg(6);
+      PackItem(new Robe(Utility.RandomNeutralHue())); // TODO: Proper hue
+      PackItem(new Sandals());
+    }
+
+    public EvilMage(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an evil mage corpse";
+
+    public override bool CanRummageCorpses => true;
+    public override bool AlwaysMurderer => true;
+    public override int Meat => 1;
+    public override int TreasureMapLevel => Core.AOS ? 1 : 0;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.MedScrolls);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/EvilMageLord.cs

@@ -0,0 +1,80 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class EvilMageLord : BaseCreature
+  {
+    [Constructible]
+    public EvilMageLord() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("evil mage lord");
+      Body = Utility.RandomList(125, 126);
+
+      PackItem(new Robe(Utility.RandomMetalHue()));
+      PackItem(new WizardsHat(Utility.RandomMetalHue()));
+
+      SetStr(81, 105);
+      SetDex(191, 215);
+      SetInt(126, 150);
+
+      SetHits(49, 63);
+
+      SetDamage(5, 10);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 35, 40);
+      SetResistance(ResistanceType.Fire, 30, 40);
+      SetResistance(ResistanceType.Cold, 30, 40);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.EvalInt, 80.2, 100.0);
+      SetSkill(SkillName.Magery, 95.1, 100.0);
+      SetSkill(SkillName.Meditation, 27.5, 50.0);
+      SetSkill(SkillName.MagicResist, 77.5, 100.0);
+      SetSkill(SkillName.Tactics, 65.0, 87.5);
+      SetSkill(SkillName.Wrestling, 20.3, 80.0);
+
+      Fame = 10500;
+      Karma = -10500;
+
+      VirtualArmor = 16;
+      PackReg(23);
+      if (Utility.RandomBool())
+        PackItem(new Shoes());
+      else
+        PackItem(new Sandals());
+    }
+
+    public EvilMageLord(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an evil mage lord corpse";
+
+    public override bool CanRummageCorpses => true;
+    public override bool AlwaysMurderer => true;
+    public override int Meat => 1;
+    public override int TreasureMapLevel => Core.AOS ? 2 : 0;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Meager);
+      AddLoot(LootPack.MedScrolls, 2);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/FireGargoyle.cs

@@ -0,0 +1,71 @@
+namespace Server.Mobiles
+{
+  public class FireGargoyle : BaseCreature
+  {
+    [Constructible]
+    public FireGargoyle() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("fire gargoyle");
+      Body = 130;
+      BaseSoundID = 0x174;
+
+      SetStr(351, 400);
+      SetDex(126, 145);
+      SetInt(226, 250);
+
+      SetHits(211, 240);
+
+      SetDamage(7, 14);
+
+      SetDamageType(ResistanceType.Physical, 20);
+      SetDamageType(ResistanceType.Fire, 80);
+
+      SetResistance(ResistanceType.Physical, 30, 35);
+      SetResistance(ResistanceType.Fire, 50, 60);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.Anatomy, 75.1, 85.0);
+      SetSkill(SkillName.EvalInt, 90.1, 105.0);
+      SetSkill(SkillName.Magery, 90.1, 105.0);
+      SetSkill(SkillName.Meditation, 90.1, 105.0);
+      SetSkill(SkillName.MagicResist, 90.1, 105.0);
+      SetSkill(SkillName.Tactics, 80.1, 100.0);
+      SetSkill(SkillName.Wrestling, 40.1, 80.0);
+
+      Fame = 3500;
+      Karma = -3500;
+
+      VirtualArmor = 32;
+    }
+
+    public FireGargoyle(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a charred corpse";
+
+    public override bool HasBreath => true; // fire breath enabled
+    public override int TreasureMapLevel => 1;
+    public override int Meat => 1;
+    public override bool CanFly => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Gems);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Gargoyle.cs

@@ -0,0 +1,74 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Gargoyle : BaseCreature
+  {
+    [Constructible]
+    public Gargoyle() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 4;
+      BaseSoundID = 372;
+
+      SetStr(146, 175);
+      SetDex(76, 95);
+      SetInt(81, 105);
+
+      SetHits(88, 105);
+
+      SetDamage(7, 14);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 30, 35);
+      SetResistance(ResistanceType.Fire, 25, 35);
+      SetResistance(ResistanceType.Cold, 5, 10);
+      SetResistance(ResistanceType.Poison, 15, 25);
+
+      SetSkill(SkillName.EvalInt, 70.1, 85.0);
+      SetSkill(SkillName.Magery, 70.1, 85.0);
+      SetSkill(SkillName.MagicResist, 70.1, 85.0);
+      SetSkill(SkillName.Tactics, 50.1, 70.0);
+      SetSkill(SkillName.Wrestling, 40.1, 80.0);
+
+      Fame = 3500;
+      Karma = -3500;
+
+      VirtualArmor = 32;
+
+      if (0.025 > Utility.RandomDouble())
+        PackItem(new GargoylesPickaxe());
+    }
+
+    public Gargoyle(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a gargoyle corpse";
+    public override string DefaultName => "a gargoyle";
+
+    public override bool CanFly => true;
+
+    public override int TreasureMapLevel => 1;
+    public override int Meat => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.MedScrolls);
+      AddLoot(LootPack.Gems, Utility.RandomMinMax(1, 4));
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/GargoyleDestroyer.cs

@@ -0,0 +1,100 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class GargoyleDestroyer : BaseCreature
+  {
+    [Constructible]
+    public GargoyleDestroyer() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0x2F3;
+      BaseSoundID = 0x174;
+
+      SetStr(760, 850);
+      SetDex(102, 150);
+      SetInt(152, 200);
+
+      SetHits(482, 485);
+
+      SetDamage(7, 14);
+
+      SetResistance(ResistanceType.Physical, 40, 60);
+      SetResistance(ResistanceType.Fire, 60, 70);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 15, 25);
+      SetResistance(ResistanceType.Energy, 15, 25);
+
+      SetSkill(SkillName.Wrestling, 90.1, 100.0);
+      SetSkill(SkillName.Tactics, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 120.4, 160.0);
+      SetSkill(SkillName.Anatomy, 50.5, 100.0);
+      SetSkill(SkillName.Swords, 90.1, 100.0);
+      SetSkill(SkillName.Macing, 90.1, 100.0);
+      SetSkill(SkillName.Fencing, 90.1, 100.0);
+      SetSkill(SkillName.Magery, 90.1, 100.0);
+      SetSkill(SkillName.EvalInt, 90.1, 100.0);
+      SetSkill(SkillName.Meditation, 90.1, 100.0);
+
+      Fame = 10000;
+      Karma = -10000;
+
+      VirtualArmor = 50;
+
+      if (0.2 > Utility.RandomDouble())
+        PackItem(new GargoylesPickaxe());
+    }
+
+    public GargoyleDestroyer(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a gargoyle corpse";
+    public override string DefaultName => "a gargoyle destroyer";
+
+    public override bool BardImmune => !Core.AOS;
+    public override int Meat => 1;
+    public override bool CanFly => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.MedScrolls);
+      AddLoot(LootPack.Gems, 2);
+    }
+
+    public override void OnDamagedBySpell(Mobile from)
+    {
+      if (from?.Alive == true && 0.4 > Utility.RandomDouble())
+        ThrowHatchet(from);
+    }
+
+    public override void OnGotMeleeAttack(Mobile attacker)
+    {
+      base.OnGotMeleeAttack(attacker);
+
+      if (attacker?.Alive == true && attacker.Weapon is BaseRanged && 0.4 > Utility.RandomDouble())
+        ThrowHatchet(attacker);
+    }
+
+    public void ThrowHatchet(Mobile to)
+    {
+      int damage = 50;
+      MovingEffect(to, 0xF43, 10, 0, false, false);
+      DoHarmful(to);
+      AOS.Damage(to, this, damage, 100, 0, 0, 0, 0);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/GargoyleEnforcer.cs

@@ -0,0 +1,80 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class GargoyleEnforcer : BaseCreature
+  {
+    [Constructible]
+    public GargoyleEnforcer() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0x2F2;
+      BaseSoundID = 0x174;
+
+      SetStr(760, 850);
+      SetDex(102, 150);
+      SetInt(152, 200);
+
+      SetHits(482, 485);
+
+      SetDamage(7, 14);
+
+      SetResistance(ResistanceType.Physical, 40, 60);
+      SetResistance(ResistanceType.Fire, 50, 60);
+      SetResistance(ResistanceType.Cold, 20, 30);
+      SetResistance(ResistanceType.Poison, 25, 35);
+      SetResistance(ResistanceType.Energy, 15, 25);
+
+      SetSkill(SkillName.MagicResist, 120.1, 130.0);
+      SetSkill(SkillName.Tactics, 70.1, 80.0);
+      SetSkill(SkillName.Wrestling, 80.1, 90.0);
+      SetSkill(SkillName.Swords, 80.1, 90.0);
+      SetSkill(SkillName.Anatomy, 70.1, 80.0);
+      SetSkill(SkillName.Magery, 80.1, 90.0);
+      SetSkill(SkillName.EvalInt, 70.3, 100.0);
+      SetSkill(SkillName.Meditation, 70.3, 100.0);
+
+      Fame = 5000;
+      Karma = -5000;
+
+      VirtualArmor = 50;
+
+      if (0.2 > Utility.RandomDouble())
+        PackItem(new GargoylesPickaxe());
+    }
+
+    public GargoyleEnforcer(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a gargoyle corpse";
+
+    public override string DefaultName => "a gargoyle enforcer";
+
+    public override bool CanFly => true;
+
+    public override int Meat => 1;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return WeaponAbility.WhirlwindAttack;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.MedScrolls);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Gazer.cs

@@ -0,0 +1,71 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Gazer : BaseCreature
+  {
+    [Constructible]
+    public Gazer() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 22;
+      BaseSoundID = 377;
+
+      SetStr(96, 125);
+      SetDex(86, 105);
+      SetInt(141, 165);
+
+      SetHits(58, 75);
+
+      SetDamage(5, 10);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 35, 40);
+      SetResistance(ResistanceType.Fire, 40, 50);
+      SetResistance(ResistanceType.Cold, 20, 30);
+      SetResistance(ResistanceType.Poison, 10, 20);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.EvalInt, 50.1, 65.0);
+      SetSkill(SkillName.Magery, 50.1, 65.0);
+      SetSkill(SkillName.MagicResist, 60.1, 75.0);
+      SetSkill(SkillName.Tactics, 50.1, 70.0);
+      SetSkill(SkillName.Wrestling, 50.1, 70.0);
+
+      Fame = 3500;
+      Karma = -3500;
+
+      VirtualArmor = 36;
+
+      PackItem(new Nightshade(4));
+    }
+
+    public Gazer(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a gazer corpse";
+    public override string DefaultName => "a gazer";
+
+    public override int TreasureMapLevel => 1;
+    public override int Meat => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Potions);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/GolemController.cs

@@ -0,0 +1,90 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class GolemController : BaseCreature
+  {
+    [Constructible]
+    public GolemController() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("golem controller");
+      Title = "the controller";
+
+      Body = 400;
+      Hue = 0x455;
+
+      AddArcane(new Robe());
+      AddArcane(new ThighBoots());
+      AddArcane(new LeatherGloves());
+      AddArcane(new Cloak());
+
+      SetStr(126, 150);
+      SetDex(96, 120);
+      SetInt(151, 175);
+
+      SetHits(76, 90);
+
+      SetDamage(6, 12);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 30, 40);
+      SetResistance(ResistanceType.Fire, 25, 35);
+      SetResistance(ResistanceType.Cold, 35, 45);
+      SetResistance(ResistanceType.Poison, 5, 15);
+      SetResistance(ResistanceType.Energy, 15, 25);
+
+      SetSkill(SkillName.EvalInt, 95.1, 100.0);
+      SetSkill(SkillName.Magery, 95.1, 100.0);
+      SetSkill(SkillName.Meditation, 95.1, 100.0);
+      SetSkill(SkillName.MagicResist, 102.5, 125.0);
+      SetSkill(SkillName.Tactics, 65.0, 87.5);
+      SetSkill(SkillName.Wrestling, 65.0, 87.5);
+
+      Fame = 4000;
+      Karma = -4000;
+
+      VirtualArmor = 16;
+
+      if (0.7 > Utility.RandomDouble())
+        PackItem(new ArcaneGem());
+    }
+
+    public GolemController(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a golem controller corpse";
+
+    public override bool ClickTitle => false;
+    public override bool ShowFameTitle => false;
+    public override bool AlwaysMurderer => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+    }
+
+    public void AddArcane(Item item)
+    {
+      if (item is IArcaneEquip eq) eq.CurArcaneCharges = eq.MaxArcaneCharges = 20;
+
+      item.Hue = ArcaneGem.DefaultArcaneHue;
+      item.LootType = LootType.Newbied;
+
+      AddItem(item);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/IceFiend.cs

@@ -0,0 +1,67 @@
+namespace Server.Mobiles
+{
+  public class IceFiend : BaseCreature
+  {
+    [Constructible]
+    public IceFiend() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 43;
+      BaseSoundID = 357;
+
+      SetStr(376, 405);
+      SetDex(176, 195);
+      SetInt(201, 225);
+
+      SetHits(226, 243);
+
+      SetDamage(8, 19);
+
+      SetSkill(SkillName.EvalInt, 80.1, 90.0);
+      SetSkill(SkillName.Magery, 80.1, 90.0);
+      SetSkill(SkillName.MagicResist, 75.1, 85.0);
+      SetSkill(SkillName.Tactics, 80.1, 90.0);
+      SetSkill(SkillName.Wrestling, 80.1, 100.0);
+
+      SetResistance(ResistanceType.Physical, 55, 65);
+      SetResistance(ResistanceType.Fire, 10, 20);
+      SetResistance(ResistanceType.Cold, 60, 70);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      Fame = 18000;
+      Karma = -18000;
+
+      VirtualArmor = 60;
+    }
+
+    public IceFiend(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an ice fiend corpse";
+    public override string DefaultName => "an ice fiend";
+
+    public override int TreasureMapLevel => 4;
+    public override int Meat => 1;
+    public override bool CanFly => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.MedScrolls, 2);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Imp.cs

@@ -0,0 +1,77 @@
+namespace Server.Mobiles
+{
+  public class Imp : BaseCreature
+  {
+    [Constructible]
+    public Imp() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 74;
+      BaseSoundID = 422;
+
+      SetStr(91, 115);
+      SetDex(61, 80);
+      SetInt(86, 105);
+
+      SetHits(55, 70);
+
+      SetDamage(10, 14);
+
+      SetDamageType(ResistanceType.Physical, 0);
+      SetDamageType(ResistanceType.Fire, 50);
+      SetDamageType(ResistanceType.Poison, 50);
+
+      SetResistance(ResistanceType.Physical, 25, 35);
+      SetResistance(ResistanceType.Fire, 40, 50);
+      SetResistance(ResistanceType.Cold, 20, 30);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.EvalInt, 20.1, 30.0);
+      SetSkill(SkillName.Magery, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 30.1, 50.0);
+      SetSkill(SkillName.Tactics, 42.1, 50.0);
+      SetSkill(SkillName.Wrestling, 40.1, 44.0);
+
+      Fame = 2500;
+      Karma = -2500;
+
+      VirtualArmor = 30;
+
+      Tamable = true;
+      ControlSlots = 2;
+      MinTameSkill = 83.1;
+    }
+
+    public Imp(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an imp corpse";
+    public override string DefaultName => "an imp";
+
+    public override int Meat => 1;
+    public override int Hides => 6;
+    public override HideType HideType => HideType.Spined;
+    public override FoodType FavoriteFood => FoodType.Meat;
+    public override PackInstinct PackInstinct => PackInstinct.Daemon;
+    public override bool CanFly => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+      AddLoot(LootPack.MedScrolls, 2);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Lich.cs

@@ -0,0 +1,81 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Lich : BaseCreature
+  {
+    [Constructible]
+    public Lich() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 24;
+      BaseSoundID = 0x3E9;
+
+      SetStr(171, 200);
+      SetDex(126, 145);
+      SetInt(276, 305);
+
+      SetHits(103, 120);
+
+      SetDamage(24, 26);
+
+      SetDamageType(ResistanceType.Physical, 10);
+      SetDamageType(ResistanceType.Cold, 40);
+      SetDamageType(ResistanceType.Energy, 50);
+
+      SetResistance(ResistanceType.Physical, 40, 60);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 55, 65);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+
+      SetSkill(SkillName.Necromancy, 89, 99.1);
+      SetSkill(SkillName.SpiritSpeak, 90.0, 99.0);
+
+      SetSkill(SkillName.EvalInt, 100.0);
+      SetSkill(SkillName.Magery, 70.1, 80.0);
+      SetSkill(SkillName.Meditation, 85.1, 95.0);
+      SetSkill(SkillName.MagicResist, 80.1, 100.0);
+      SetSkill(SkillName.Tactics, 70.1, 90.0);
+
+      Fame = 8000;
+      Karma = -8000;
+
+      VirtualArmor = 50;
+      PackItem(new GnarledStaff());
+      PackNecroReg(17, 24);
+    }
+
+    public Lich(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a lich's corpse";
+    public override string DefaultName => "a lich";
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override bool CanRummageCorpses => true;
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override int TreasureMapLevel => 3;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.MedScrolls, 2);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/LichLord.cs

@@ -0,0 +1,80 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class LichLord : BaseCreature
+  {
+    [Constructible]
+    public LichLord() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 79;
+      BaseSoundID = 412;
+
+      SetStr(416, 505);
+      SetDex(146, 165);
+      SetInt(566, 655);
+
+      SetHits(250, 303);
+
+      SetDamage(11, 13);
+
+      SetDamageType(ResistanceType.Physical, 0);
+      SetDamageType(ResistanceType.Cold, 60);
+      SetDamageType(ResistanceType.Energy, 40);
+
+      SetResistance(ResistanceType.Physical, 40, 50);
+      SetResistance(ResistanceType.Fire, 30, 40);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 50, 60);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.Necromancy, 90, 110.0);
+      SetSkill(SkillName.SpiritSpeak, 90.0, 110.0);
+
+      SetSkill(SkillName.EvalInt, 90.1, 100.0);
+      SetSkill(SkillName.Magery, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 150.5, 200.0);
+      SetSkill(SkillName.Tactics, 50.1, 70.0);
+      SetSkill(SkillName.Wrestling, 60.1, 80.0);
+
+      Fame = 18000;
+      Karma = -18000;
+
+      VirtualArmor = 50;
+      PackItem(new GnarledStaff());
+      PackNecroReg(12, 40);
+    }
+
+    public LichLord(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a lich's corpse";
+    public override string DefaultName => "a lich lord";
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override bool CanRummageCorpses => true;
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override int TreasureMapLevel => 4;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+      AddLoot(LootPack.MedScrolls, 2);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/OrcishMage.cs

@@ -0,0 +1,104 @@
+using Server.Items;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+  public class OrcishMage : BaseCreature
+  {
+    [Constructible]
+    public OrcishMage() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 140;
+      BaseSoundID = 0x45A;
+
+      SetStr(116, 150);
+      SetDex(91, 115);
+      SetInt(161, 185);
+
+      SetHits(70, 90);
+
+      SetDamage(4, 14);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 25, 35);
+      SetResistance(ResistanceType.Fire, 30, 40);
+      SetResistance(ResistanceType.Cold, 20, 30);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.EvalInt, 60.1, 72.5);
+      SetSkill(SkillName.Magery, 60.1, 72.5);
+      SetSkill(SkillName.MagicResist, 60.1, 75.0);
+      SetSkill(SkillName.Tactics, 50.1, 65.0);
+      SetSkill(SkillName.Wrestling, 40.1, 50.0);
+
+      Fame = 3000;
+      Karma = -3000;
+
+      VirtualArmor = 30;
+
+
+      PackReg(6);
+
+      if (0.05 > Utility.RandomDouble())
+        PackItem(new OrcishKinMask());
+    }
+
+    public OrcishMage(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a glowing orc corpse";
+    public override InhumanSpeech SpeechType => InhumanSpeech.Orc;
+
+    public override string DefaultName => "an orcish mage";
+
+    public override bool CanRummageCorpses => true;
+    public override int TreasureMapLevel => 1;
+    public override int Meat => 1;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.SavagesAndOrcs;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.LowScrolls);
+    }
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (m.Player && m.FindItemOnLayer(Layer.Helm) is OrcishKinMask)
+        return false;
+
+      return base.IsEnemy(m);
+    }
+
+    public override void AggressiveAction(Mobile aggressor, bool criminal)
+    {
+      base.AggressiveAction(aggressor, criminal);
+
+      Item item = aggressor.FindItemOnLayer(Layer.Helm);
+
+      if (item is OrcishKinMask)
+      {
+        AOS.Damage(aggressor, 50, 0, 100, 0, 0, 0);
+        item.Delete();
+        aggressor.FixedParticles(0x36BD, 20, 10, 5044, EffectLayer.Head);
+        aggressor.PlaySound(0x307);
+      }
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/RatmanMage.cs

@@ -0,0 +1,83 @@
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+  public class RatmanMage : BaseCreature
+  {
+    [Constructible]
+    public RatmanMage() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("ratman");
+      Body = 0x8F;
+      BaseSoundID = 437;
+
+      SetStr(146, 180);
+      SetDex(101, 130);
+      SetInt(186, 210);
+
+      SetHits(88, 108);
+
+      SetDamage(7, 14);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 40, 45);
+      SetResistance(ResistanceType.Fire, 10, 20);
+      SetResistance(ResistanceType.Cold, 10, 20);
+      SetResistance(ResistanceType.Poison, 10, 20);
+      SetResistance(ResistanceType.Energy, 10, 20);
+
+      SetSkill(SkillName.EvalInt, 70.1, 80.0);
+      SetSkill(SkillName.Magery, 70.1, 80.0);
+      SetSkill(SkillName.MagicResist, 65.1, 90.0);
+      SetSkill(SkillName.Tactics, 50.1, 75.0);
+      SetSkill(SkillName.Wrestling, 50.1, 75.0);
+
+      Fame = 7500;
+      Karma = -7500;
+
+      VirtualArmor = 44;
+
+      PackReg(6);
+
+      if (0.02 > Utility.RandomDouble())
+        PackStatue();
+    }
+
+    public RatmanMage(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a glowing ratman corpse";
+    public override InhumanSpeech SpeechType => InhumanSpeech.Ratman;
+
+    public override bool CanRummageCorpses => true;
+    public override int Meat => 1;
+    public override int Hides => 8;
+    public override HideType HideType => HideType.Spined;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.LowScrolls);
+    }
+
+    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();
+
+      if (Body == 42)
+      {
+        Body = 0x8F;
+        Hue = 0;
+      }
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/SavageShaman.cs

@@ -0,0 +1,279 @@
+using System;
+using System.Collections.Generic;
+using Server.Items;
+using Server.Spells;
+
+namespace Server.Mobiles
+{
+  public class SavageShaman : BaseCreature
+  {
+    [Constructible]
+    public SavageShaman() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("savage shaman");
+
+      if (Utility.RandomBool())
+        Body = 184;
+      else
+        Body = 183;
+
+      SetStr(126, 145);
+      SetDex(91, 110);
+      SetInt(161, 185);
+
+      SetDamage(4, 10);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 30, 40);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 20, 30);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.EvalInt, 77.5, 100.0);
+      SetSkill(SkillName.Fencing, 62.5, 85.0);
+      SetSkill(SkillName.Macing, 62.5, 85.0);
+      SetSkill(SkillName.Magery, 72.5, 95.0);
+      SetSkill(SkillName.Meditation, 77.5, 100.0);
+      SetSkill(SkillName.MagicResist, 77.5, 100.0);
+      SetSkill(SkillName.Swords, 62.5, 85.0);
+      SetSkill(SkillName.Tactics, 62.5, 85.0);
+      SetSkill(SkillName.Wrestling, 62.5, 85.0);
+
+      Fame = 1000;
+      Karma = -1000;
+
+      PackReg(10, 15);
+      PackItem(new Bandage(Utility.RandomMinMax(1, 15)));
+
+      if (0.1 > Utility.RandomDouble())
+        PackItem(new TribalBerry());
+
+      AddItem(new BoneArms());
+      AddItem(new BoneLegs());
+      AddItem(new DeerMask());
+    }
+
+    public SavageShaman(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a savage corpse";
+
+    public override int Meat => 1;
+    public override bool AlwaysMurderer => true;
+    public override bool ShowFameTitle => false;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.SavagesAndOrcs;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+    }
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (m.BodyMod == 183 || m.BodyMod == 184)
+        return false;
+
+      return base.IsEnemy(m);
+    }
+
+    public override void AggressiveAction(Mobile aggressor, bool criminal)
+    {
+      base.AggressiveAction(aggressor, criminal);
+
+      if (aggressor.BodyMod == 183 || aggressor.BodyMod == 184)
+      {
+        AOS.Damage(aggressor, 50, 0, 100, 0, 0, 0);
+        aggressor.BodyMod = 0;
+        aggressor.HueMod = -1;
+        aggressor.FixedParticles(0x36BD, 20, 10, 5044, EffectLayer.Head);
+        aggressor.PlaySound(0x307);
+        aggressor.SendLocalizedMessage(1040008); // Your skin is scorched as the tribal paint burns away!
+
+        if (aggressor is PlayerMobile mobile)
+          mobile.SavagePaintExpiration = TimeSpan.Zero;
+      }
+    }
+
+    public override void AlterMeleeDamageTo(Mobile to, ref int damage)
+    {
+      if (to is Dragon || to is WhiteWyrm || to is SwampDragon || to is Drake || to is Nightmare || to is Hiryu ||
+          to is LesserHiryu || to is Daemon)
+        damage *= 3;
+    }
+
+    public override void OnGotMeleeAttack(Mobile attacker)
+    {
+      base.OnGotMeleeAttack(attacker);
+
+      if (0.1 > Utility.RandomDouble())
+        BeginSavageDance();
+    }
+
+    public void BeginSavageDance()
+    {
+      if (Map == null)
+        return;
+
+      List<SavageShaman> list = new List<SavageShaman>();
+
+      foreach (Mobile m in GetMobilesInRange(8))
+        if (m != this && m is SavageShaman ss)
+          list.Add(ss);
+
+      Animate(111, 5, 1, true, false, 0); // Do a little dance...
+
+      if (AIObject != null)
+        AIObject.NextMove = Core.TickCount + 1000;
+
+      if (list.Count >= 3)
+      {
+        for (int i = 0; i < list.Count; ++i)
+        {
+          SavageShaman dancer = list[i];
+
+          dancer.Animate(111, 5, 1, true, false, 0); // Get down tonight...
+
+          if (dancer.AIObject != null)
+            dancer.AIObject.NextMove = Core.TickCount + 1000;
+        }
+
+        Timer.DelayCall(TimeSpan.FromSeconds(1.0), EndSavageDance);
+      }
+    }
+
+    public void EndSavageDance()
+    {
+      if (Deleted)
+        return;
+
+      IPooledEnumerable<Mobile> eable = GetMobilesInRange(8);
+      
+      switch (Utility.Random(3))
+      {
+        case 0: /* greater heal */
+        {
+          foreach (Mobile m in eable)
+          {
+            bool isFriendly = m is Savage || m is SavageRider || m is SavageShaman || m is SavageRidgeback;
+
+            if (!isFriendly)
+              continue;
+
+            if (m.Poisoned || MortalStrike.IsWounded(m) || !CanBeBeneficial(m))
+              continue;
+
+            DoBeneficial(m);
+
+            // Algorithm: (40% of magery) + (1-10)
+
+            int toHeal = (int)(Skills.Magery.Value * 0.4);
+            toHeal += Utility.Random(1, 10);
+
+            m.Heal(toHeal, this);
+
+            m.FixedParticles(0x376A, 9, 32, 5030, EffectLayer.Waist);
+            m.PlaySound(0x202);
+          }
+
+          break;
+        }
+        case 1: /* lightning */
+        {
+          foreach (Mobile m in eable)
+          {
+            bool isFriendly = m is Savage || m is SavageRider || m is SavageShaman || m is SavageRidgeback;
+
+            if (isFriendly)
+              continue;
+
+            if (!CanBeHarmful(m))
+              continue;
+
+            DoHarmful(m);
+
+            double damage;
+
+            if (Core.AOS)
+            {
+              int baseDamage = 6 + (int)(Skills.EvalInt.Value / 5.0);
+
+              damage = Utility.RandomMinMax(baseDamage, baseDamage + 3);
+            }
+            else
+            {
+              damage = Utility.Random(12, 9);
+            }
+
+            m.BoltEffect(0);
+
+            SpellHelper.Damage(TimeSpan.FromSeconds(0.25), m, this, damage, 0, 0, 0, 0, 100);
+          }
+
+          break;
+        }
+        case 2: /* poison */
+        {
+          foreach (Mobile m in eable)
+          {
+            bool isFriendly = m is Savage || m is SavageRider || m is SavageShaman || m is SavageRidgeback;
+
+            if (isFriendly)
+              continue;
+
+            if (!CanBeHarmful(m))
+              continue;
+
+            DoHarmful(m);
+
+            m.Spell?.OnCasterHurt();
+
+            m.Paralyzed = false;
+
+            double total = Skills.Magery.Value + Skills.Poisoning.Value;
+
+            double dist = GetDistanceToSqrt(m);
+
+            if (dist >= 3.0)
+              total -= (dist - 3.0) * 10.0;
+
+            int level;
+
+            if (total >= 200.0 && Utility.Random(1, 100) <= 10)
+              level = 3;
+            else if (total > 170.0)
+              level = 2;
+            else if (total > 130.0)
+              level = 1;
+            else
+              level = 0;
+
+            m.ApplyPoison(this, Poison.GetPoison(level));
+
+            m.FixedParticles(0x374A, 10, 15, 5021, EffectLayer.Waist);
+            m.PlaySound(0x474);
+          }
+
+          break;
+        }
+      }
+      
+      eable.Free();
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Shade.cs

@@ -0,0 +1,71 @@
+namespace Server.Mobiles
+{
+  public class Shade : BaseCreature
+  {
+    [Constructible]
+    public Shade() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 26;
+      Hue = 0x4001;
+      BaseSoundID = 0x482;
+
+      SetStr(76, 100);
+      SetDex(76, 95);
+      SetInt(36, 60);
+
+      SetHits(46, 60);
+
+      SetDamage(7, 11);
+
+      SetDamageType(ResistanceType.Physical, 50);
+      SetDamageType(ResistanceType.Cold, 50);
+
+      SetResistance(ResistanceType.Physical, 25, 30);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 10, 20);
+
+      SetSkill(SkillName.EvalInt, 55.1, 70.0);
+      SetSkill(SkillName.Magery, 55.1, 70.0);
+      SetSkill(SkillName.MagicResist, 55.1, 70.0);
+      SetSkill(SkillName.Tactics, 45.1, 60.0);
+      SetSkill(SkillName.Wrestling, 45.1, 55.0);
+
+      Fame = 4000;
+      Karma = -4000;
+
+      VirtualArmor = 28;
+
+      PackReg(10);
+    }
+
+    public Shade(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a ghostly corpse";
+    public override string DefaultName => "a shade";
+
+    public override bool BleedImmune => true;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/SkeletalMage.cs

@@ -0,0 +1,78 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class SkeletalMage : BaseCreature
+  {
+    [Constructible]
+    public SkeletalMage() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 148;
+      BaseSoundID = 451;
+
+      SetStr(76, 100);
+      SetDex(56, 75);
+      SetInt(186, 210);
+
+      SetHits(46, 60);
+
+      SetDamage(3, 7);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 35, 40);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.EvalInt, 60.1, 70.0);
+      SetSkill(SkillName.Magery, 60.1, 70.0);
+      SetSkill(SkillName.MagicResist, 55.1, 70.0);
+      SetSkill(SkillName.Tactics, 45.1, 60.0);
+      SetSkill(SkillName.Wrestling, 45.1, 55.0);
+      SetSkill(SkillName.Necromancy, 89, 99.1);
+      SetSkill(SkillName.SpiritSpeak, 90.0, 99.0);
+
+      Fame = 3000;
+      Karma = -3000;
+
+      VirtualArmor = 38;
+      PackReg(3);
+      PackNecroReg(3, 10);
+      PackItem(new Bone());
+    }
+
+    public SkeletalMage(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a skeletal corpse";
+    public override string DefaultName => "a skeletal mage";
+
+    public override bool BleedImmune => true;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override Poison PoisonImmune => Poison.Regular;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.LowScrolls);
+      AddLoot(LootPack.Potions);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Spectre.cs

@@ -0,0 +1,71 @@
+namespace Server.Mobiles
+{
+  public class Spectre : BaseCreature
+  {
+    [Constructible]
+    public Spectre() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 26;
+      Hue = 0x4001;
+      BaseSoundID = 0x482;
+
+      SetStr(76, 100);
+      SetDex(76, 95);
+      SetInt(36, 60);
+
+      SetHits(46, 60);
+
+      SetDamage(7, 11);
+
+      SetDamageType(ResistanceType.Physical, 50);
+      SetDamageType(ResistanceType.Cold, 50);
+
+      SetResistance(ResistanceType.Physical, 25, 30);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 10, 20);
+
+      SetSkill(SkillName.EvalInt, 55.1, 70.0);
+      SetSkill(SkillName.Magery, 55.1, 70.0);
+      SetSkill(SkillName.MagicResist, 55.1, 70.0);
+      SetSkill(SkillName.Tactics, 45.1, 60.0);
+      SetSkill(SkillName.Wrestling, 45.1, 55.0);
+
+      Fame = 4000;
+      Karma = -4000;
+
+      VirtualArmor = 28;
+
+      PackReg(10);
+    }
+
+    public Spectre(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a ghostly corpse";
+    public override string DefaultName => "a spectre";
+
+    public override bool BleedImmune => true;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Succubus.cs

@@ -0,0 +1,112 @@
+namespace Server.Mobiles
+{
+  public class Succubus : BaseCreature
+  {
+    [Constructible]
+    public Succubus() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 149;
+      BaseSoundID = 0x4B0;
+
+      SetStr(488, 620);
+      SetDex(121, 170);
+      SetInt(498, 657);
+
+      SetHits(312, 353);
+
+      SetDamage(18, 28);
+
+      SetDamageType(ResistanceType.Physical, 75);
+      SetDamageType(ResistanceType.Energy, 25);
+
+      SetResistance(ResistanceType.Physical, 80, 90);
+      SetResistance(ResistanceType.Fire, 70, 80);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 50, 60);
+      SetResistance(ResistanceType.Energy, 50, 60);
+
+      SetSkill(SkillName.EvalInt, 90.1, 100.0);
+      SetSkill(SkillName.Magery, 99.1, 100.0);
+      SetSkill(SkillName.Meditation, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 100.5, 150.0);
+      SetSkill(SkillName.Tactics, 80.1, 90.0);
+      SetSkill(SkillName.Wrestling, 80.1, 90.0);
+
+      Fame = 24000;
+      Karma = -24000;
+
+      VirtualArmor = 80;
+    }
+
+    public Succubus(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a succubus corpse";
+    public override string DefaultName => "a succubus";
+
+    public override int Meat => 1;
+    public override int TreasureMapLevel => 5;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich, 2);
+      AddLoot(LootPack.MedScrolls, 2);
+    }
+
+    public void DrainLife()
+    {
+      IPooledEnumerable<Mobile> eable = GetMobilesInRange(2);
+
+      foreach (Mobile m in eable)
+      {
+        if (m == this || !CanBeHarmful(m) ||
+            !(m is BaseCreature creature && (creature.Controlled || creature.Summoned || creature.Team != Team) ||
+            m.Player))
+          continue;
+        
+        DoHarmful(m);
+
+        m.FixedParticles(0x374A, 10, 15, 5013, 0x496, 0, EffectLayer.Waist);
+        m.PlaySound(0x231);
+
+        //m.SendMessage( "You feel the life drain out of you!" );
+
+        int toDrain = Utility.RandomMinMax(10, 40);
+
+        Hits += toDrain;
+        m.Damage(toDrain, this);
+      }
+      
+      eable.Free();
+    }
+
+    public override void OnGaveMeleeAttack(Mobile defender)
+    {
+      base.OnGaveMeleeAttack(defender);
+
+      if (0.1 >= Utility.RandomDouble())
+        DrainLife();
+    }
+
+    public override void OnGotMeleeAttack(Mobile attacker)
+    {
+      base.OnGotMeleeAttack(attacker);
+
+      if (0.1 >= Utility.RandomDouble())
+        DrainLife();
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Titan.cs

@@ -0,0 +1,74 @@
+using Server.Engines.Plants;
+
+namespace Server.Mobiles
+{
+  public class Titan : BaseCreature
+  {
+    [Constructible]
+    public Titan() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 76;
+      BaseSoundID = 609;
+
+      SetStr(536, 585);
+      SetDex(126, 145);
+      SetInt(281, 305);
+
+      SetHits(322, 351);
+
+      SetDamage(13, 16);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 30, 40);
+      SetResistance(ResistanceType.Cold, 25, 35);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.EvalInt, 85.1, 100.0);
+      SetSkill(SkillName.Magery, 85.1, 100.0);
+      SetSkill(SkillName.MagicResist, 80.2, 110.0);
+      SetSkill(SkillName.Tactics, 60.1, 80.0);
+      SetSkill(SkillName.Wrestling, 40.1, 50.0);
+
+      Fame = 11500;
+      Karma = -11500;
+
+      VirtualArmor = 40;
+
+      if (Core.ML && Utility.RandomDouble() < .33)
+        PackItem(Seed.RandomPeculiarSeed(1));
+    }
+
+    public Titan(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a titans corpse";
+    public override string DefaultName => "a titan";
+
+    public override int Meat => 4;
+    public override Poison PoisonImmune => Poison.Regular;
+    public override int TreasureMapLevel => 5;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.MedScrolls);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Magic/Wraith.cs

@@ -0,0 +1,71 @@
+namespace Server.Mobiles
+{
+  public class Wraith : BaseCreature
+  {
+    [Constructible]
+    public Wraith() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 26;
+      Hue = 0x4001;
+      BaseSoundID = 0x482;
+
+      SetStr(76, 100);
+      SetDex(76, 95);
+      SetInt(36, 60);
+
+      SetHits(46, 60);
+
+      SetDamage(7, 11);
+
+      SetDamageType(ResistanceType.Physical, 50);
+      SetDamageType(ResistanceType.Cold, 50);
+
+      SetResistance(ResistanceType.Physical, 25, 30);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 10, 20);
+
+      SetSkill(SkillName.EvalInt, 55.1, 70.0);
+      SetSkill(SkillName.Magery, 55.1, 70.0);
+      SetSkill(SkillName.MagicResist, 55.1, 70.0);
+      SetSkill(SkillName.Tactics, 45.1, 60.0);
+      SetSkill(SkillName.Wrestling, 45.1, 55.0);
+
+      Fame = 4000;
+      Karma = -4000;
+
+      VirtualArmor = 28;
+
+      PackReg(10);
+    }
+
+    public Wraith(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a ghostly corpse";
+    public override string DefaultName => "a wraith";
+
+    public override bool BleedImmune => true;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/ArcticOgreLord.cs

@@ -0,0 +1,70 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  [TypeAlias("Server.Mobiles.ArticOgreLord")]
+  public class ArcticOgreLord : BaseCreature
+  {
+    [Constructible]
+    public ArcticOgreLord() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 135;
+      BaseSoundID = 427;
+
+      SetStr(767, 945);
+      SetDex(66, 75);
+      SetInt(46, 70);
+
+      SetHits(476, 552);
+
+      SetDamage(20, 25);
+
+      SetDamageType(ResistanceType.Physical, 30);
+      SetDamageType(ResistanceType.Cold, 70);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Cold, 60, 70);
+      SetResistance(ResistanceType.Poison, 100);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.MagicResist, 125.1, 140.0);
+      SetSkill(SkillName.Tactics, 90.1, 100.0);
+      SetSkill(SkillName.Wrestling, 90.1, 100.0);
+
+      Fame = 15000;
+      Karma = -15000;
+
+      VirtualArmor = 50;
+
+      PackItem(new Club());
+    }
+
+    public ArcticOgreLord(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a frozen ogre lord's corpse";
+    public override string DefaultName => "an arctic ogre lord";
+
+    public override Poison PoisonImmune => Poison.Regular;
+    public override int TreasureMapLevel => 3;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+      AddLoot(LootPack.Rich);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/BoneKnight.cs

@@ -0,0 +1,95 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class BoneKnight : BaseCreature
+  {
+    [Constructible]
+    public BoneKnight() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 57;
+      BaseSoundID = 451;
+
+      SetStr(196, 250);
+      SetDex(76, 95);
+      SetInt(36, 60);
+
+      SetHits(118, 150);
+
+      SetDamage(8, 18);
+
+      SetDamageType(ResistanceType.Physical, 40);
+      SetDamageType(ResistanceType.Cold, 60);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.MagicResist, 65.1, 80.0);
+      SetSkill(SkillName.Tactics, 85.1, 100.0);
+      SetSkill(SkillName.Wrestling, 85.1, 95.0);
+
+      Fame = 3000;
+      Karma = -3000;
+
+      VirtualArmor = 40;
+
+      switch (Utility.Random(6))
+      {
+        case 0:
+          PackItem(new PlateArms());
+          break;
+        case 1:
+          PackItem(new PlateChest());
+          break;
+        case 2:
+          PackItem(new PlateGloves());
+          break;
+        case 3:
+          PackItem(new PlateGorget());
+          break;
+        case 4:
+          PackItem(new PlateLegs());
+          break;
+        case 5:
+          PackItem(new PlateHelm());
+          break;
+      }
+
+      PackSlayer();
+      PackItem(new Scimitar());
+      PackItem(new WoodenShield());
+    }
+
+    public BoneKnight(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a skeletal corpse";
+    public override string DefaultName => "a bone knight";
+
+    public override bool BleedImmune => true;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Meager);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/Brigand.cs

@@ -0,0 +1,110 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Brigand : BaseCreature
+  {
+    [Constructible]
+    public Brigand() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      SpeechHue = Utility.RandomDyedHue();
+      Title = "the brigand";
+      Hue = Race.Human.RandomSkinHue();
+
+      if (Female = Utility.RandomBool())
+      {
+        Body = 0x191;
+        Name = NameList.RandomName("female");
+        AddItem(new Skirt(Utility.RandomNeutralHue()));
+      }
+      else
+      {
+        Body = 0x190;
+        Name = NameList.RandomName("male");
+        AddItem(new ShortPants(Utility.RandomNeutralHue()));
+      }
+
+      SetStr(86, 100);
+      SetDex(81, 95);
+      SetInt(61, 75);
+
+      SetDamage(10, 23);
+
+      SetSkill(SkillName.Fencing, 66.0, 97.5);
+      SetSkill(SkillName.Macing, 65.0, 87.5);
+      SetSkill(SkillName.MagicResist, 25.0, 47.5);
+      SetSkill(SkillName.Swords, 65.0, 87.5);
+      SetSkill(SkillName.Tactics, 65.0, 87.5);
+      SetSkill(SkillName.Wrestling, 15.0, 37.5);
+
+      Fame = 1000;
+      Karma = -1000;
+
+      AddItem(new Boots(Utility.RandomNeutralHue()));
+      AddItem(new FancyShirt());
+      AddItem(new Bandana());
+
+      switch (Utility.Random(7))
+      {
+        case 0:
+          AddItem(new Longsword());
+          break;
+        case 1:
+          AddItem(new Cutlass());
+          break;
+        case 2:
+          AddItem(new Broadsword());
+          break;
+        case 3:
+          AddItem(new Axe());
+          break;
+        case 4:
+          AddItem(new Club());
+          break;
+        case 5:
+          AddItem(new Dagger());
+          break;
+        case 6:
+          AddItem(new Spear());
+          break;
+      }
+
+      Utility.AssignRandomHair(this);
+    }
+
+    public Brigand(Serial serial) : base(serial)
+    {
+    }
+
+    public override bool ClickTitle => false;
+
+    public override bool AlwaysMurderer => true;
+
+    public override void OnDeath(Container c)
+    {
+      base.OnDeath(c);
+
+      if (Utility.RandomDouble() < 0.9)
+        c.DropItem(new SeveredHumanEars());
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/ChaosDaemon.cs

@@ -0,0 +1,71 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class ChaosDaemon : BaseCreature
+  {
+    [Constructible]
+    public ChaosDaemon() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 792;
+      BaseSoundID = 0x3E9;
+
+      SetStr(106, 130);
+      SetDex(171, 200);
+      SetInt(56, 80);
+
+      SetHits(91, 110);
+
+      SetDamage(12, 17);
+
+      SetDamageType(ResistanceType.Physical, 85);
+      SetDamageType(ResistanceType.Fire, 15);
+
+      SetResistance(ResistanceType.Physical, 50, 60);
+      SetResistance(ResistanceType.Fire, 60, 70);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.MagicResist, 85.1, 95.0);
+      SetSkill(SkillName.Tactics, 70.1, 80.0);
+      SetSkill(SkillName.Wrestling, 95.1, 100.0);
+
+      Fame = 3000;
+      Karma = -4000;
+
+      VirtualArmor = 15;
+    }
+
+    public ChaosDaemon(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a chaos daemon corpse";
+
+    public override string DefaultName => "a chaos daemon";
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return WeaponAbility.CrushingBlow;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Meager);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/Cursed.cs

@@ -0,0 +1,84 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Cursed : BaseCreature
+  {
+    [Constructible]
+    public Cursed() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Title = "the Cursed";
+
+      Hue = Utility.RandomMinMax(0x8596, 0x8599);
+      Body = 0x190;
+      Name = NameList.RandomName("male");
+      BaseSoundID = 471;
+
+      AddItem(new ShortPants(Utility.RandomNeutralHue()));
+      AddItem(new Shirt(Utility.RandomNeutralHue()));
+
+      BaseWeapon weapon = Loot.RandomWeapon();
+      weapon.Movable = false;
+      AddItem(weapon);
+
+      SetStr(91, 100);
+      SetDex(86, 95);
+      SetInt(61, 70);
+
+      SetHits(91, 120);
+
+      SetDamage(5, 13);
+
+      SetResistance(ResistanceType.Physical, 15, 25);
+      SetResistance(ResistanceType.Fire, 5, 10);
+      SetResistance(ResistanceType.Cold, 25, 35);
+      SetResistance(ResistanceType.Poison, 5, 10);
+      SetResistance(ResistanceType.Energy, 5, 10);
+
+      SetSkill(SkillName.Fencing, 46.0, 77.5);
+      SetSkill(SkillName.Macing, 35.0, 57.5);
+      SetSkill(SkillName.MagicResist, 53.5, 62.5);
+      SetSkill(SkillName.Swords, 55.0, 77.5);
+      SetSkill(SkillName.Tactics, 60.0, 82.5);
+      SetSkill(SkillName.Poisoning, 60.0, 82.5);
+
+      Fame = 1000;
+      Karma = -2000;
+    }
+
+    public Cursed(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an inhuman corpse";
+    public override bool ClickTitle => false;
+    public override bool ShowFameTitle => false;
+
+    public override bool AlwaysMurderer => true;
+
+    public override int GetAttackSound()
+    {
+      return -1;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+      //AddLoot( LootPack.Miscellaneous );
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/Cyclops.cs

@@ -0,0 +1,66 @@
+namespace Server.Mobiles
+{
+  public class Cyclops : BaseCreature
+  {
+    [Constructible]
+    public Cyclops() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 75;
+      BaseSoundID = 604;
+
+      SetStr(336, 385);
+      SetDex(96, 115);
+      SetInt(31, 55);
+
+      SetHits(202, 231);
+      SetMana(0);
+
+      SetDamage(7, 23);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 45, 50);
+      SetResistance(ResistanceType.Fire, 30, 40);
+      SetResistance(ResistanceType.Cold, 25, 35);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.MagicResist, 60.3, 105.0);
+      SetSkill(SkillName.Tactics, 80.1, 100.0);
+      SetSkill(SkillName.Wrestling, 80.1, 90.0);
+
+      Fame = 4500;
+      Karma = -4500;
+
+      VirtualArmor = 48;
+    }
+
+    public Cyclops(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a cyclopean corpse";
+    public override string DefaultName => "a cyclopean warrior";
+
+    public override int Meat => 4;
+    public override int TreasureMapLevel => 3;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Average);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/Doppleganger.cs

@@ -0,0 +1,62 @@
+namespace Server.Mobiles
+{
+  public class Doppleganger : BaseCreature
+  {
+    [Constructible]
+    public Doppleganger() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0x309;
+      BaseSoundID = 0x451;
+
+      SetStr(81, 110);
+      SetDex(56, 75);
+      SetInt(81, 105);
+
+      SetHits(101, 120);
+
+      SetDamage(8, 12);
+
+      SetResistance(ResistanceType.Physical, 50, 60);
+      SetResistance(ResistanceType.Fire, 10, 20);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 50, 60);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.MagicResist, 75.1, 85.0);
+      SetSkill(SkillName.Tactics, 70.1, 80.0);
+      SetSkill(SkillName.Wrestling, 80.1, 90.0);
+
+      Fame = 1000;
+      Karma = -1000;
+
+      VirtualArmor = 55;
+    }
+
+    public Doppleganger(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a doppleganger corpse";
+    public override string DefaultName => "a doppleganger";
+
+    public override int Hides => 6;
+    public override int Meat => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/ElfBrigand.cs

@@ -0,0 +1,135 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  // TODO: Needs some Spellweaving abilities
+  public class ElfBrigand : BaseCreature
+  {
+    [Constructible]
+    public ElfBrigand() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      SpeechHue = Utility.RandomDyedHue();
+      Title = "the brigand";
+      Race = Race.Elf;
+      Hue = Race.RandomSkinHue();
+
+      if (Female = Utility.RandomBool())
+      {
+        Body = 0x25E;
+        Name = NameList.RandomName("female elf brigand");
+
+        switch (Utility.Random(2))
+        {
+          case 0:
+            AddItem(new Skirt(Utility.RandomNondyedHue()));
+            break;
+          case 1:
+            AddItem(new Kilt(Utility.RandomNondyedHue()));
+            break;
+        }
+      }
+      else
+      {
+        Body = 0x25D;
+        Name = NameList.RandomName("male elf brigand");
+        AddItem(new ShortPants(Utility.RandomNondyedHue()));
+      }
+
+      SetStr(86, 100);
+      SetDex(81, 95);
+      SetInt(61, 75);
+
+      SetDamage(10, 23);
+
+      SetSkill(SkillName.Fencing, 66.0, 97.5);
+      SetSkill(SkillName.Macing, 65.0, 87.5);
+      SetSkill(SkillName.MagicResist, 25.0, 47.5);
+      SetSkill(SkillName.Swords, 65.0, 87.5);
+      SetSkill(SkillName.Tactics, 65.0, 87.5);
+      SetSkill(SkillName.Wrestling, 15.0, 37.5);
+
+      Fame = 1000;
+      Karma = -1000;
+
+      switch (Utility.Random(4))
+      {
+        case 0:
+          AddItem(new Boots());
+          break;
+        case 1:
+          AddItem(new ThighBoots());
+          break;
+        case 2:
+          AddItem(new Sandals());
+          break;
+        case 3:
+          AddItem(new Shoes());
+          break;
+      }
+
+      AddItem(new Shirt(Utility.RandomNondyedHue()));
+
+      switch (Utility.Random(7))
+      {
+        case 0:
+          AddItem(new Longsword());
+          break;
+        case 1:
+          AddItem(new Cutlass());
+          break;
+        case 2:
+          AddItem(new Broadsword());
+          break;
+        case 3:
+          AddItem(new Axe());
+          break;
+        case 4:
+          AddItem(new Club());
+          break;
+        case 5:
+          AddItem(new Dagger());
+          break;
+        case 6:
+          AddItem(new Spear());
+          break;
+      }
+
+      Utility.AssignRandomHair(this);
+    }
+
+    public ElfBrigand(Serial serial) : base(serial)
+    {
+    }
+
+    public override bool ClickTitle => false;
+
+    public override bool AlwaysMurderer => true;
+
+    public override void OnDeath(Container c)
+    {
+      base.OnDeath(c);
+
+      if (Utility.RandomDouble() < 0.9)
+        c.DropItem(new SeveredElfEars());
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/EnslavedGargoyle.cs

@@ -0,0 +1,68 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class EnslavedGargoyle : BaseCreature
+  {
+    [Constructible]
+    public EnslavedGargoyle() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0x2F1;
+      BaseSoundID = 0x174;
+
+      SetStr(302, 360);
+      SetDex(76, 95);
+      SetInt(81, 105);
+
+      SetHits(186, 212);
+
+      SetDamage(7, 14);
+
+      SetResistance(ResistanceType.Physical, 30, 40);
+      SetResistance(ResistanceType.Fire, 50, 70);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 25, 30);
+      SetResistance(ResistanceType.Energy, 25, 30);
+
+      SetSkill(SkillName.MagicResist, 70.1, 85.0);
+      SetSkill(SkillName.Tactics, 50.1, 70.0);
+      SetSkill(SkillName.Wrestling, 40.1, 80.0);
+
+      Fame = 3500;
+      Karma = 0;
+
+      VirtualArmor = 35;
+
+      if (0.2 > Utility.RandomDouble())
+        PackItem(new GargoylesPickaxe());
+    }
+
+    public EnslavedGargoyle(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an enslaved gargoyle corpse";
+    public override string DefaultName => "an enslaved gargoyle";
+
+    public override int Meat => 1;
+    public override int TreasureMapLevel => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average, 2);
+      AddLoot(LootPack.Gems);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/Ettin.cs

@@ -0,0 +1,67 @@
+namespace Server.Mobiles
+{
+  public class Ettin : BaseCreature
+  {
+    [Constructible]
+    public Ettin() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 18;
+      BaseSoundID = 367;
+
+      SetStr(136, 165);
+      SetDex(56, 75);
+      SetInt(31, 55);
+
+      SetHits(82, 99);
+
+      SetDamage(7, 17);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 35, 40);
+      SetResistance(ResistanceType.Fire, 15, 25);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 15, 25);
+      SetResistance(ResistanceType.Energy, 15, 25);
+
+      SetSkill(SkillName.MagicResist, 40.1, 55.0);
+      SetSkill(SkillName.Tactics, 50.1, 70.0);
+      SetSkill(SkillName.Wrestling, 50.1, 60.0);
+
+      Fame = 3000;
+      Karma = -3000;
+
+      VirtualArmor = 38;
+    }
+
+    public Ettin(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an ettins corpse";
+    public override string DefaultName => "an ettin";
+
+    public override bool CanRummageCorpses => true;
+    public override int TreasureMapLevel => 1;
+    public override int Meat => 4;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Potions);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/Executioner.cs

@@ -0,0 +1,88 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Executioner : BaseCreature
+  {
+    [Constructible]
+    public Executioner() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      SpeechHue = Utility.RandomDyedHue();
+      Title = "the executioner";
+      Hue = Race.Human.RandomSkinHue();
+
+      if (Female = Utility.RandomBool())
+      {
+        Body = 0x191;
+        Name = NameList.RandomName("female");
+        AddItem(new Skirt(Utility.RandomRedHue()));
+      }
+      else
+      {
+        Body = 0x190;
+        Name = NameList.RandomName("male");
+        AddItem(new ShortPants(Utility.RandomRedHue()));
+      }
+
+      SetStr(386, 400);
+      SetDex(151, 165);
+      SetInt(161, 175);
+
+      SetDamage(8, 10);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 25, 30);
+      SetResistance(ResistanceType.Cold, 25, 30);
+      SetResistance(ResistanceType.Poison, 10, 20);
+      SetResistance(ResistanceType.Energy, 10, 20);
+
+      SetSkill(SkillName.Anatomy, 125.0);
+      SetSkill(SkillName.Fencing, 46.0, 77.5);
+      SetSkill(SkillName.Macing, 35.0, 57.5);
+      SetSkill(SkillName.Poisoning, 60.0, 82.5);
+      SetSkill(SkillName.MagicResist, 83.5, 92.5);
+      SetSkill(SkillName.Swords, 125.0);
+      SetSkill(SkillName.Tactics, 125.0);
+      SetSkill(SkillName.Lumberjacking, 125.0);
+
+      Fame = 5000;
+      Karma = -5000;
+
+      VirtualArmor = 40;
+
+      AddItem(new ThighBoots(Utility.RandomRedHue()));
+      AddItem(new Surcoat(Utility.RandomRedHue()));
+      AddItem(new ExecutionersAxe());
+
+      Utility.AssignRandomHair(this);
+    }
+
+    public Executioner(Serial serial) : base(serial)
+    {
+    }
+
+    public override bool AlwaysMurderer => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+      AddLoot(LootPack.Meager);
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/FrostTroll.cs

@@ -0,0 +1,69 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class FrostTroll : BaseCreature
+  {
+    [Constructible]
+    public FrostTroll() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 55;
+      BaseSoundID = 461;
+
+      SetStr(227, 265);
+      SetDex(66, 85);
+      SetInt(46, 70);
+
+      SetHits(140, 156);
+
+      SetDamage(14, 20);
+
+      SetDamageType(ResistanceType.Physical, 75);
+      SetDamageType(ResistanceType.Cold, 25);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 5, 10);
+      SetResistance(ResistanceType.Energy, 5, 10);
+
+      SetSkill(SkillName.MagicResist, 65.1, 80.0);
+      SetSkill(SkillName.Tactics, 80.1, 100.0);
+      SetSkill(SkillName.Wrestling, 80.1, 100.0);
+
+      Fame = 4000;
+      Karma = -4000;
+
+      VirtualArmor = 50;
+
+      PackItem(new DoubleAxe()); // TODO: Weapon??
+    }
+
+    public FrostTroll(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a frost troll corpse";
+    public override string DefaultName => "a frost troll";
+
+    public override int Meat => 2;
+    public override int TreasureMapLevel => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Gems);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/GazerLarva.cs

@@ -0,0 +1,63 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class GazerLarva : BaseCreature
+  {
+    [Constructible]
+    public GazerLarva() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 778;
+      BaseSoundID = 377;
+
+      SetStr(76, 100);
+      SetDex(51, 75);
+      SetInt(56, 80);
+
+      SetHits(36, 47);
+
+      SetDamage(2, 9);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 15, 25);
+
+      SetSkill(SkillName.MagicResist, 70.0);
+      SetSkill(SkillName.Tactics, 70.0);
+      SetSkill(SkillName.Wrestling, 70.0);
+
+      Fame = 900;
+      Karma = -900;
+
+      VirtualArmor = 25;
+
+      PackItem(new Nightshade(Utility.RandomMinMax(2, 3)));
+    }
+
+    public GazerLarva(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a gazer larva corpse";
+    public override string DefaultName => "a gazer larva";
+
+    public override int Meat => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Poor);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/Ghoul.cs

@@ -0,0 +1,68 @@
+namespace Server.Mobiles
+{
+  public class Ghoul : BaseCreature
+  {
+    [Constructible]
+    public Ghoul() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 153;
+      BaseSoundID = 0x482;
+
+      SetStr(76, 100);
+      SetDex(76, 95);
+      SetInt(36, 60);
+
+      SetHits(46, 60);
+      SetMana(0);
+
+      SetDamage(7, 9);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 25, 30);
+      SetResistance(ResistanceType.Cold, 20, 30);
+      SetResistance(ResistanceType.Poison, 5, 10);
+      SetResistance(ResistanceType.Energy, 10, 20);
+
+      SetSkill(SkillName.MagicResist, 45.1, 60.0);
+      SetSkill(SkillName.Tactics, 45.1, 60.0);
+      SetSkill(SkillName.Wrestling, 45.1, 55.0);
+
+      Fame = 2500;
+      Karma = -2500;
+
+      VirtualArmor = 28;
+
+      PackItem(Loot.RandomWeapon());
+    }
+
+    public Ghoul(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a ghostly corpse";
+    public override string DefaultName => "a ghoul";
+
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Regular;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/GreaterMongbat.cs

@@ -0,0 +1,67 @@
+namespace Server.Mobiles
+{
+  public class GreaterMongbat : BaseCreature
+  {
+    [Constructible]
+    public GreaterMongbat() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 39;
+      BaseSoundID = 422;
+
+      SetStr(56, 80);
+      SetDex(61, 80);
+      SetInt(26, 50);
+
+      SetHits(34, 48);
+      SetStam(61, 80);
+      SetMana(26, 50);
+
+      SetDamage(5, 7);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 15, 25);
+
+      SetSkill(SkillName.MagicResist, 15.1, 30.0);
+      SetSkill(SkillName.Tactics, 35.1, 50.0);
+      SetSkill(SkillName.Wrestling, 20.1, 35.0);
+
+      Fame = 450;
+      Karma = -450;
+
+      VirtualArmor = 10;
+
+      Tamable = true;
+      ControlSlots = 1;
+      MinTameSkill = 71.1;
+    }
+
+    public GreaterMongbat(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a mongbat corpse";
+    public override string DefaultName => "a greater mongbat";
+
+    public override int Meat => 1;
+    public override int Hides => 6;
+    public override FoodType FavoriteFood => FoodType.Meat;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Poor);
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/Guardian.cs

@@ -0,0 +1,86 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Guardian : BaseCreature
+  {
+    [Constructible]
+    public Guardian() : base(AIType.AI_Archer, FightMode.Aggressor, 10, 1, 0.2, 0.4)
+    {
+      InitStats(100, 125, 25);
+      Title = "the guardian";
+
+      SpeechHue = Utility.RandomDyedHue();
+
+      Hue = Race.Human.RandomSkinHue();
+
+      if (Female = Utility.RandomBool())
+      {
+        Body = 0x191;
+        Name = NameList.RandomName("female");
+      }
+      else
+      {
+        Body = 0x190;
+        Name = NameList.RandomName("male");
+      }
+
+      new ForestOstard().Rider = this;
+
+      PlateChest chest = new PlateChest();
+      chest.Hue = 0x966;
+      AddItem(chest);
+      PlateArms arms = new PlateArms();
+      arms.Hue = 0x966;
+      AddItem(arms);
+      PlateGloves gloves = new PlateGloves();
+      gloves.Hue = 0x966;
+      AddItem(gloves);
+      PlateGorget gorget = new PlateGorget();
+      gorget.Hue = 0x966;
+      AddItem(gorget);
+      PlateLegs legs = new PlateLegs();
+      legs.Hue = 0x966;
+      AddItem(legs);
+      PlateHelm helm = new PlateHelm();
+      helm.Hue = 0x966;
+      AddItem(helm);
+
+
+      Bow bow = new Bow();
+
+      bow.Movable = false;
+      bow.Crafter = this;
+      bow.Quality = WeaponQuality.Exceptional;
+
+      AddItem(bow);
+
+      PackItem(new Arrow(250));
+      PackGold(250, 500);
+
+      Skills.Anatomy.Base = 120.0;
+      Skills.Tactics.Base = 120.0;
+      Skills.Archery.Base = 120.0;
+      Skills.MagicResist.Base = 120.0;
+      Skills.DetectHidden.Base = 100.0;
+    }
+
+    public Guardian(Serial serial) : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version 
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/HeadlessOne.cs

@@ -0,0 +1,62 @@
+namespace Server.Mobiles
+{
+  public class HeadlessOne : BaseCreature
+  {
+    [Constructible]
+    public HeadlessOne() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 31;
+      Hue = Race.Human.RandomSkinHue() & 0x7FFF;
+      BaseSoundID = 0x39D;
+
+      SetStr(26, 50);
+      SetDex(36, 55);
+      SetInt(16, 30);
+
+      SetHits(16, 30);
+
+      SetDamage(5, 10);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 15, 20);
+
+      SetSkill(SkillName.MagicResist, 15.1, 20.0);
+      SetSkill(SkillName.Tactics, 25.1, 40.0);
+      SetSkill(SkillName.Wrestling, 25.1, 40.0);
+
+      Fame = 450;
+      Karma = -450;
+
+      VirtualArmor = 18;
+    }
+
+    public HeadlessOne(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a headless corpse";
+    public override string DefaultName => "a headless one";
+
+    public override bool CanRummageCorpses => true;
+    public override int Meat => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Poor);
+      // TODO: body parts
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/HordeMinion.cs

@@ -0,0 +1,85 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class HordeMinion : BaseCreature
+  {
+    [Constructible]
+    public HordeMinion() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 776;
+      BaseSoundID = 357;
+
+      SetStr(16, 40);
+      SetDex(31, 60);
+      SetInt(11, 25);
+
+      SetHits(10, 24);
+
+      SetDamage(5, 10);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 15, 20);
+      SetResistance(ResistanceType.Fire, 5, 10);
+
+      SetSkill(SkillName.MagicResist, 10.0);
+      SetSkill(SkillName.Tactics, 0.1, 15.0);
+      SetSkill(SkillName.Wrestling, 25.1, 40.0);
+
+      Fame = 500;
+      Karma = -500;
+
+      VirtualArmor = 18;
+
+      AddItem(new LightSource());
+
+      PackItem(new Bone(3));
+      // TODO: Body parts
+    }
+
+    public HordeMinion(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a horde minion corpse";
+    public override string DefaultName => "a horde minion";
+
+    public override int GetIdleSound()
+    {
+      return 338;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 338;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 338;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 406;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 194;
+    }
+
+    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();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/Juggernaut.cs

@@ -0,0 +1,154 @@
+using System;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Mobiles
+{
+  public class Juggernaut : BaseCreature
+  {
+    private bool m_Stunning;
+
+    [Constructible]
+    public Juggernaut() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.3, 0.6)
+    {
+      Body = 768;
+
+
+      SetStr(301, 400);
+      SetDex(51, 70);
+      SetInt(51, 100);
+
+      SetHits(181, 240);
+
+      SetDamage(12, 19);
+
+      SetDamageType(ResistanceType.Physical, 50);
+      SetDamageType(ResistanceType.Fire, 25);
+      SetDamageType(ResistanceType.Energy, 25);
+
+      SetResistance(ResistanceType.Physical, 65, 75);
+      SetResistance(ResistanceType.Fire, 35, 45);
+      SetResistance(ResistanceType.Cold, 35, 45);
+      SetResistance(ResistanceType.Poison, 15, 25);
+      SetResistance(ResistanceType.Energy, 10, 20);
+
+      SetSkill(SkillName.Anatomy, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 140.1, 150.0);
+      SetSkill(SkillName.Tactics, 90.1, 100.0);
+      SetSkill(SkillName.Wrestling, 90.1, 100.0);
+
+      Fame = 12000;
+      Karma = -12000;
+
+      VirtualArmor = 70;
+
+      if (0.1 > Utility.RandomDouble())
+        PackItem(new PowerCrystal());
+
+      if (0.4 > Utility.RandomDouble())
+        PackItem(new ClockworkAssembly());
+    }
+
+    public Juggernaut(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a juggernaut corpse";
+
+    public override string DefaultName => "a blackthorn juggernaut";
+
+    public override bool AlwaysMurderer => true;
+    public override bool BardImmune => !Core.AOS;
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override int Meat => 1;
+    public override int TreasureMapLevel => 5;
+
+    public override void OnDeath(Container c)
+    {
+      base.OnDeath(c);
+
+      if (0.05 > Utility.RandomDouble())
+      {
+        if (!IsParagon)
+        {
+          if (0.75 > Utility.RandomDouble())
+            c.DropItem(DawnsMusicGear.RandomCommon);
+          else
+            c.DropItem(DawnsMusicGear.RandomUncommon);
+        }
+        else
+        {
+          c.DropItem(DawnsMusicGear.RandomRare);
+        }
+      }
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Gems, 1);
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x423;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x23B;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x140;
+    }
+
+    public override void OnGaveMeleeAttack(Mobile defender)
+    {
+      base.OnGaveMeleeAttack(defender);
+
+      if (!m_Stunning && 0.3 > Utility.RandomDouble())
+      {
+        m_Stunning = true;
+
+        defender.Animate(21, 6, 1, true, false, 0);
+        PlaySound(0xEE);
+        defender.LocalOverheadMessage(MessageType.Regular, 0x3B2, false,
+          "You have been stunned by a colossal blow!");
+
+        if (Weapon is BaseWeapon weapon)
+          weapon.OnHit(this, defender);
+
+        if (defender.Alive)
+        {
+          defender.Frozen = true;
+          Timer.DelayCall(TimeSpan.FromSeconds(5.0), Recover_Callback, defender);
+        }
+      }
+    }
+
+    private void Recover_Callback(Mobile defender)
+    {
+      defender.Frozen = false;
+      defender.Combatant = null;
+      defender.LocalOverheadMessage(MessageType.Regular, 0x3B2, false, "You recover your senses.");
+      m_Stunning = false;
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/Humanoid/Melee/KhaldunRevenant.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class KhaldunRevenant : BaseCreature
+  {
+    private static HashSet<Mobile> m_Set = new HashSet<Mobile>();
+    private DateTime m_ExpireTime;
+
+    private Mobile m_Target;
+
+    public KhaldunRevenant(Mobile target) : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.18, 0.36)
+    {
+      Body = 0x3CA;
+      Hue = 0x41CE;
+
+      m_Target = target;
+      m_ExpireTime = DateTime.UtcNow + TimeSpan.FromMinutes(10.0);
+
+      SetStr(401, 500);
+      SetDex(296, 315);
+      SetInt(101, 200);
+
+      SetHits(241, 300);
+      SetStam(242, 280);
+
+      SetDamage(20, 30);
+
+      SetDamageType(ResistanceType.Physical, 50);
+      SetDamageType(ResistanceType.Cold, 50);
+
+      SetSkill(SkillName.MagicResist, 100.1, 150.0);
+      SetSkill(SkillName.Tactics, 90.1, 100.0);
+      SetSkill(SkillName.Swords, 140.1, 150.0);
+      SetSkill(SkillName.Wrestling, 90.1, 100.0);
+
+      SetResistance(ResistanceType.Physical, 55, 65);
+      SetResistance(ResistanceType.Fire, 30, 40);
+      SetResistance(ResistanceType.Cold, 60, 70);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      Fame = 0;
+      Karma = 0;
+
+      VirtualArmor = 60;
+
+      Halberd weapon = new Halberd { Hue = 0x41CE, Movable = false };
+
+      AddItem(weapon);
+    }
+
+    public KhaldunRevenant(Serial serial) : base(serial)
+    {
+    }
+
+    public override bool DeleteCorpseOnDeath => true;
+
+    public override Mobile ConstantFocus => m_Target;
+    public override bool AlwaysAttackable => true;
+
+    public override string DefaultName => "a revenant";
+
+    public override bool BardImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public static void Initialize()
+    {
+      EventSink.PlayerDeath += EventSink_PlayerDeath;
+    }
+
+    public static void EventSink_PlayerDeath(PlayerDeathEventArgs e)
+    {
+      Mobile m = e.Mobile;
+      Mobile lastKiller = m.LastKiller;
+
+      if (lastKiller is BaseCreature creature)
+        lastKiller = creature.GetMaster();
+
+      if (IsInsideKhaldun(m) && IsInsideKhaldun(lastKiller) && lastKiller.Player && !m_Set.Contains(lastKiller))
+        foreach (AggressorInfo ai in m.Aggressors)
+          if (ai.Attacker == lastKiller && ai.CanReportMurder)
+          {
+            SummonRevenant(m, lastKiller);
+            break;
+          }
+    }
+
+    public static void SummonRevenant(Mobile victim, Mobile killer)
+    {
+      KhaldunRevenant revenant = new KhaldunRevenant(killer);
+
+      revenant.MoveToWorld(victim.Location, victim.Map);
+      revenant.Combatant = killer;
+      revenant.FixedParticles(0, 0, 0, 0x13A7, EffectLayer.Waist);
+      Effects.PlaySound(revenant.Location, revenant.Map, 0x29);
+
+      m_Set.Add(killer);
+    }
+
+    public static bool IsInsideKhaldun(Mobile from)
+    {
+      return from?.Region?.IsPartOf("Khaldun") == true;
+    }
+
+    public override void DisplayPaperdollTo(Mobile to)
+    {
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x1BF;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x107;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0xFD;
+    }
+
+    public override void OnThink()
+    {
+      if (!m_Target.Alive || DateTime.UtcNow > m_ExpireTime)
+      {
+        Delete();
+        return;
+      }
+
+      //Combatant = m_Target;
+      //FocusMob = m_Target;
+
+      if (AIObject != null)
+        AIObject.Action = ActionType.Combat;
+
+      base.OnThink();
+    }
+
+    public override bool OnBeforeDeath()
+    {
+      Effects.SendLocationEffect(Location, Map, 0x376A, 10, 1);
+      return true;
+    }
+
+    public override void OnDelete()
+    {
+      if (m_Target != null)
+        m_Set.Remove(m_Target);
+
+      base.OnDelete();
+    }
+
+    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();
+
+      Delete();
+    }
+  }
+}