Reorganizes Project (#41)

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();
+    }
+  }
+}

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

@@ -0,0 +1,140 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class KhaldunSummoner : BaseCreature
+  {
+    [Constructible]
+    public KhaldunSummoner() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0x190;
+      Title = "the Summoner";
+
+      SetStr(351, 400);
+      SetDex(101, 150);
+      SetInt(502, 700);
+
+      SetHits(421, 480);
+
+      SetDamage(5, 15);
+
+      SetDamageType(ResistanceType.Physical, 75);
+      SetDamageType(ResistanceType.Cold, 25);
+
+      SetResistance(ResistanceType.Physical, 35, 40);
+      SetResistance(ResistanceType.Fire, 25, 30);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 25, 35);
+      SetResistance(ResistanceType.Energy, 25, 35);
+
+      SetSkill(SkillName.Wrestling, 90.1, 100.0);
+      SetSkill(SkillName.Tactics, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 90.1, 100.0);
+      SetSkill(SkillName.Magery, 90.1, 100.0);
+      SetSkill(SkillName.EvalInt, 100.0);
+      SetSkill(SkillName.Meditation, 120.1, 130.0);
+
+      VirtualArmor = 36;
+      Fame = 10000;
+      Karma = -10000;
+
+      LeatherGloves gloves = new LeatherGloves();
+      gloves.Hue = 0x66D;
+      AddItem(gloves);
+
+      BoneHelm helm = new BoneHelm();
+      helm.Hue = 0x835;
+      AddItem(helm);
+
+      Necklace necklace = new Necklace();
+      necklace.Hue = 0x66D;
+      AddItem(necklace);
+
+      Cloak cloak = new Cloak();
+      cloak.Hue = 0x66D;
+      AddItem(cloak);
+
+      Kilt kilt = new Kilt();
+      kilt.Hue = 0x66D;
+      AddItem(kilt);
+
+      Sandals sandals = new Sandals();
+      sandals.Hue = 0x66D;
+      AddItem(sandals);
+    }
+
+    public KhaldunSummoner(Serial serial) : base(serial)
+    {
+    }
+
+    public override bool ClickTitle => false;
+    public override bool ShowFameTitle => false;
+
+    public override string DefaultName => "Zealot of Khaldun";
+
+    public override bool AlwaysMurderer => true;
+    public override bool Unprovokable => true;
+
+    public override int GetIdleSound()
+    {
+      return 0x184;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x286;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x288;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x19F;
+    }
+
+    public override bool OnBeforeDeath()
+    {
+      BoneMagi rm = new BoneMagi();
+      rm.Team = Team;
+      rm.Combatant = Combatant;
+      rm.NoKillAwards = true;
+
+      if (rm.Backpack == null)
+      {
+        Backpack pack = new Backpack();
+        pack.Movable = false;
+        rm.AddItem(pack);
+      }
+
+      for (int i = 0; i < 2; i++)
+      {
+        LootPack.FilthyRich.Generate(this, rm.Backpack, true, LootPack.GetLuckChanceForKiller(this));
+        LootPack.FilthyRich.Generate(this, rm.Backpack, false, LootPack.GetLuckChanceForKiller(this));
+      }
+
+      Effects.PlaySound(this, Map, GetDeathSound());
+      Effects.SendLocationEffect(Location, Map, 0x3709, 30, 10, 0x835, 0);
+      rm.MoveToWorld(Location, Map);
+
+      Delete();
+      return 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/KhaldunZealot.cs

@@ -0,0 +1,149 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class KhaldunZealot : BaseCreature
+  {
+    [Constructible]
+    public KhaldunZealot() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0x190;
+      Title = "the Knight";
+      Hue = 0;
+
+      SetStr(351, 400);
+      SetDex(151, 165);
+      SetInt(76, 100);
+
+      SetHits(448, 470);
+
+      SetDamage(15, 25);
+
+      SetDamageType(ResistanceType.Physical, 75);
+      SetDamageType(ResistanceType.Cold, 25);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 25, 30);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 25, 35);
+      SetResistance(ResistanceType.Energy, 25, 35);
+
+      SetSkill(SkillName.Wrestling, 70.1, 80.0);
+      SetSkill(SkillName.Swords, 120.1, 130.0);
+      SetSkill(SkillName.Anatomy, 120.1, 130.0);
+      SetSkill(SkillName.MagicResist, 90.1, 100.0);
+      SetSkill(SkillName.Tactics, 90.1, 100.0);
+
+      Fame = 10000;
+      Karma = -10000;
+      VirtualArmor = 40;
+
+      VikingSword weapon = new VikingSword();
+      weapon.Hue = 0x835;
+      weapon.Movable = false;
+      AddItem(weapon);
+
+      MetalShield shield = new MetalShield();
+      shield.Hue = 0x835;
+      shield.Movable = false;
+      AddItem(shield);
+
+      BoneHelm helm = new BoneHelm();
+      helm.Hue = 0x835;
+      AddItem(helm);
+
+      BoneArms arms = new BoneArms();
+      arms.Hue = 0x835;
+      AddItem(arms);
+
+      BoneGloves gloves = new BoneGloves();
+      gloves.Hue = 0x835;
+      AddItem(gloves);
+
+      BoneChest tunic = new BoneChest();
+      tunic.Hue = 0x835;
+      AddItem(tunic);
+
+      BoneLegs legs = new BoneLegs();
+      legs.Hue = 0x835;
+      AddItem(legs);
+
+      AddItem(new Boots());
+    }
+
+    public KhaldunZealot(Serial serial) : base(serial)
+    {
+    }
+
+    public override bool ClickTitle => false;
+    public override bool ShowFameTitle => false;
+
+    public override string DefaultName => "Zealot of Khaldun";
+
+    public override bool AlwaysMurderer => true;
+    public override bool Unprovokable => true;
+    public override Poison PoisonImmune => Poison.Deadly;
+
+    public override int GetIdleSound()
+    {
+      return 0x184;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x286;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x288;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x19F;
+    }
+
+    public override bool OnBeforeDeath()
+    {
+      BoneKnight rm = new BoneKnight();
+      rm.Team = Team;
+      rm.Combatant = Combatant;
+      rm.NoKillAwards = true;
+
+      if (rm.Backpack == null)
+      {
+        Backpack pack = new Backpack();
+        pack.Movable = false;
+        rm.AddItem(pack);
+      }
+
+      for (int i = 0; i < 2; i++)
+      {
+        LootPack.FilthyRich.Generate(this, rm.Backpack, true, LootPack.GetLuckChanceForKiller(this));
+        LootPack.FilthyRich.Generate(this, rm.Backpack, false, LootPack.GetLuckChanceForKiller(this));
+      }
+
+      Effects.PlaySound(this, Map, GetDeathSound());
+      Effects.SendLocationEffect(Location, Map, 0x3709, 30, 10, 0x835, 0);
+      rm.MoveToWorld(Location, Map);
+
+      Delete();
+      return 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/Moloch.cs

@@ -0,0 +1,69 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Moloch : BaseCreature
+  {
+    [Constructible]
+    public Moloch() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0x311;
+      BaseSoundID = 0x300;
+
+      SetStr(331, 360);
+      SetDex(66, 85);
+      SetInt(41, 65);
+
+      SetHits(171, 200);
+
+      SetDamage(15, 23);
+
+      SetResistance(ResistanceType.Physical, 60, 70);
+      SetResistance(ResistanceType.Fire, 60, 70);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.MagicResist, 65.1, 75.0);
+      SetSkill(SkillName.Tactics, 75.1, 90.0);
+      SetSkill(SkillName.Wrestling, 70.1, 90.0);
+
+      Fame = 7500;
+      Karma = -7500;
+
+      VirtualArmor = 32;
+    }
+
+    public Moloch(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a moloch corpse";
+
+    public override string DefaultName => "a moloch";
+
+    public override Poison PoisonImmune => Poison.Regular;
+
+    public override WeaponAbility GetWeaponAbility()
+    {
+      return WeaponAbility.ConcussionBlow;
+    }
+
+    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/Melee/Mongbat.cs

@@ -0,0 +1,67 @@
+namespace Server.Mobiles
+{
+  public class Mongbat : BaseCreature
+  {
+    [Constructible]
+    public Mongbat() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 39;
+      BaseSoundID = 422;
+
+      SetStr(6, 10);
+      SetDex(26, 38);
+      SetInt(6, 14);
+
+      SetHits(4, 6);
+      SetMana(0);
+
+      SetDamage(1, 2);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 5, 10);
+
+      SetSkill(SkillName.MagicResist, 5.1, 14.0);
+      SetSkill(SkillName.Tactics, 5.1, 10.0);
+      SetSkill(SkillName.Wrestling, 5.1, 10.0);
+
+      Fame = 150;
+      Karma = -150;
+
+      VirtualArmor = 10;
+
+      Tamable = true;
+      ControlSlots = 1;
+      MinTameSkill = -18.9;
+    }
+
+    public Mongbat(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a mongbat corpse";
+    public override string DefaultName => "a mongbat";
+
+    public override bool CanFly => true;
+
+    public override int Meat => 1;
+    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/Mummy.cs

@@ -0,0 +1,78 @@
+using Server.Engines.Plants;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Mummy : BaseCreature
+  {
+    [Constructible]
+    public Mummy() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.4, 0.8)
+    {
+      Body = 154;
+      BaseSoundID = 471;
+
+      SetStr(346, 370);
+      SetDex(71, 90);
+      SetInt(26, 40);
+
+      SetHits(208, 222);
+
+      SetDamage(13, 23);
+
+      SetDamageType(ResistanceType.Physical, 40);
+      SetDamageType(ResistanceType.Cold, 60);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 10, 20);
+      SetResistance(ResistanceType.Cold, 50, 60);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.MagicResist, 15.1, 40.0);
+      SetSkill(SkillName.Tactics, 35.1, 50.0);
+      SetSkill(SkillName.Wrestling, 35.1, 50.0);
+
+      Fame = 4000;
+      Karma = -4000;
+
+      VirtualArmor = 50;
+
+      if (Core.ML && Utility.RandomDouble() < .33)
+        PackItem(Seed.RandomPeculiarSeed(2));
+
+      PackItem(new Garlic(5));
+      PackItem(new Bandage(10));
+    }
+
+    public Mummy(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a mummy corpse";
+    public override string DefaultName => "a mummy";
+
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lesser;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Gems);
+      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/Ogre.cs

@@ -0,0 +1,71 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Ogre : BaseCreature
+  {
+    [Constructible]
+    public Ogre() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 1;
+      BaseSoundID = 427;
+
+      SetStr(166, 195);
+      SetDex(46, 65);
+      SetInt(46, 70);
+
+      SetHits(100, 117);
+      SetMana(0);
+
+      SetDamage(9, 11);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 30, 35);
+      SetResistance(ResistanceType.Fire, 15, 25);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 15, 25);
+      SetResistance(ResistanceType.Energy, 25);
+
+      SetSkill(SkillName.MagicResist, 55.1, 70.0);
+      SetSkill(SkillName.Tactics, 60.1, 70.0);
+      SetSkill(SkillName.Wrestling, 70.1, 80.0);
+
+      Fame = 3000;
+      Karma = -3000;
+
+      VirtualArmor = 32;
+
+      PackItem(new Club());
+    }
+
+    public Ogre(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an ogre corpse";
+    public override string DefaultName => "an ogre";
+
+    public override bool CanRummageCorpses => true;
+    public override int TreasureMapLevel => 1;
+    public override int Meat => 2;
+
+    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/Melee/OgreLord.cs

@@ -0,0 +1,75 @@
+using Server.Ethics;
+using Server.Factions;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class OgreLord : BaseCreature
+  {
+    [Constructible]
+    public OgreLord() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 83;
+      BaseSoundID = 427;
+
+      SetStr(767, 945);
+      SetDex(66, 75);
+      SetInt(46, 70);
+
+      SetHits(476, 552);
+
+      SetDamage(20, 25);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 30, 40);
+      SetResistance(ResistanceType.Cold, 30, 40);
+      SetResistance(ResistanceType.Poison, 40, 50);
+      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 OgreLord(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an ogre lords corpse";
+    public override Faction FactionAllegiance => Minax.Instance;
+    public override Ethic EthicAllegiance => Ethic.Evil;
+
+    public override string DefaultName => "an ogre lord";
+
+    public override bool CanRummageCorpses => true;
+    public override Poison PoisonImmune => Poison.Regular;
+    public override int TreasureMapLevel => 3;
+    public override int Meat => 2;
+
+    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();
+    }
+  }
+}

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

@@ -0,0 +1,134 @@
+using Server.Items;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+  public class Orc : BaseCreature
+  {
+    [Constructible]
+    public Orc() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("orc");
+      Body = 17;
+      BaseSoundID = 0x45A;
+
+      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, 50.1, 75.0);
+      SetSkill(SkillName.Tactics, 55.1, 80.0);
+      SetSkill(SkillName.Wrestling, 50.1, 70.0);
+
+      Fame = 1500;
+      Karma = -1500;
+
+      VirtualArmor = 28;
+
+      switch (Utility.Random(20))
+      {
+        case 0:
+          PackItem(new Scimitar());
+          break;
+        case 1:
+          PackItem(new Katana());
+          break;
+        case 2:
+          PackItem(new WarMace());
+          break;
+        case 3:
+          PackItem(new WarHammer());
+          break;
+        case 4:
+          PackItem(new Kryss());
+          break;
+        case 5:
+          PackItem(new Pitchfork());
+          break;
+      }
+
+      PackItem(new ThighBoots());
+
+      switch (Utility.Random(3))
+      {
+        case 0:
+          PackItem(new Ribs());
+          break;
+        case 1:
+          PackItem(new Shaft());
+          break;
+        case 2:
+          PackItem(new Candle());
+          break;
+      }
+
+      if (0.2 > Utility.RandomDouble())
+        PackItem(new BolaBall());
+    }
+
+    public Orc(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an orcish corpse";
+    public override InhumanSpeech SpeechType => InhumanSpeech.Orc;
+
+    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.Meager);
+    }
+
+    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/Melee/OrcBomber.cs

@@ -0,0 +1,157 @@
+using System;
+using Server.Items;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+  public class OrcBomber : BaseCreature
+  {
+    private DateTime m_NextBomb;
+    private int m_Thrown;
+
+    [Constructible]
+    public OrcBomber() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 182;
+      BaseSoundID = 0x45A;
+
+      SetStr(147, 215);
+      SetDex(91, 115);
+      SetInt(61, 85);
+
+      SetHits(95, 123);
+
+      SetDamage(1, 8);
+
+      SetDamageType(ResistanceType.Physical, 75);
+      SetDamageType(ResistanceType.Fire, 25);
+
+      SetResistance(ResistanceType.Physical, 25, 35);
+      SetResistance(ResistanceType.Fire, 30, 40);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 15, 20);
+      SetResistance(ResistanceType.Energy, 25, 30);
+
+      SetSkill(SkillName.MagicResist, 70.1, 85.0);
+      SetSkill(SkillName.Swords, 60.1, 85.0);
+      SetSkill(SkillName.Tactics, 75.1, 90.0);
+      SetSkill(SkillName.Wrestling, 60.1, 85.0);
+
+      Fame = 2500;
+      Karma = -2500;
+
+      VirtualArmor = 30;
+
+      PackItem(new SulfurousAsh(Utility.RandomMinMax(6, 10)));
+      PackItem(new MandrakeRoot(Utility.RandomMinMax(6, 10)));
+      PackItem(new BlackPearl(Utility.RandomMinMax(6, 10)));
+      PackItem(new MortarPestle());
+      PackItem(new LesserExplosionPotion());
+
+      if (0.2 > Utility.RandomDouble())
+        PackItem(new BolaBall());
+    }
+
+    public OrcBomber(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an orcish corpse";
+    public override InhumanSpeech SpeechType => InhumanSpeech.Orc;
+
+    public override string DefaultName => "an orc bomber";
+
+    public override bool CanRummageCorpses => true;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.SavagesAndOrcs;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Meager);
+    }
+
+    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 OnActionCombat()
+    {
+      Mobile combatant = Combatant;
+
+      if (combatant?.Deleted != false || combatant.Map != Map || !InRange(combatant, 12) ||
+          !CanBeHarmful(combatant) || !InLOS(combatant))
+        return;
+
+      if (DateTime.UtcNow >= m_NextBomb)
+      {
+        ThrowBomb(combatant);
+
+        m_Thrown++;
+
+        if (0.75 >= Utility.RandomDouble() && m_Thrown % 2 == 1) // 75% chance to quickly throw another bomb
+          m_NextBomb = DateTime.UtcNow + TimeSpan.FromSeconds(3.0);
+        else
+          m_NextBomb = DateTime.UtcNow + TimeSpan.FromSeconds(5.0 + 10.0 * Utility.RandomDouble()); // 5-15 seconds
+      }
+    }
+
+    public void ThrowBomb(Mobile m)
+    {
+      DoHarmful(m);
+
+      MovingParticles(m, 0x1C19, 1, 0, false, true, 0, 0, 9502, 6014, 0x11D, EffectLayer.Waist, 0);
+
+      new InternalTimer(m, this).Start();
+    }
+
+    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();
+    }
+
+    private class InternalTimer : Timer
+    {
+      private Mobile m_Mobile, m_From;
+
+      public InternalTimer(Mobile m, Mobile from) : base(TimeSpan.FromSeconds(1.0))
+      {
+        m_Mobile = m;
+        m_From = from;
+        Priority = TimerPriority.TwoFiftyMS;
+      }
+
+      protected override void OnTick()
+      {
+        m_Mobile.PlaySound(0x11D);
+        AOS.Damage(m_Mobile, m_From, Utility.RandomMinMax(10, 20), 0, 100, 0, 0, 0);
+      }
+    }
+  }
+}

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

@@ -0,0 +1,137 @@
+using System.Linq;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class OrcBrute : BaseCreature
+  {
+    [Constructible]
+    public OrcBrute() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 189;
+      BaseSoundID = 0x45A;
+
+      SetStr(767, 945);
+      SetDex(66, 75);
+      SetInt(46, 70);
+
+      SetHits(476, 552);
+
+      SetDamage(20, 25);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 40, 50);
+      SetResistance(ResistanceType.Cold, 25, 35);
+      SetResistance(ResistanceType.Poison, 25, 35);
+      SetResistance(ResistanceType.Energy, 25, 35);
+
+      SetSkill(SkillName.Macing, 90.1, 100.0);
+      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;
+
+      Item ore = new ShadowIronOre(25);
+      ore.ItemID = 0x19B9;
+      PackItem(ore);
+      PackItem(new IronIngot(10));
+
+      if (0.05 > Utility.RandomDouble())
+        PackItem(new OrcishKinMask());
+
+      if (0.2 > Utility.RandomDouble())
+        PackItem(new BolaBall());
+    }
+
+    public OrcBrute(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an orcish corpse";
+    public override string DefaultName => "an orc brute";
+
+    public override bool BardImmune => !Core.AOS;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override int Meat => 2;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.SavagesAndOrcs;
+
+    public override bool CanRummageCorpses => true;
+    public override bool AutoDispel => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+      AddLoot(LootPack.Rich);
+    }
+
+    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 OnDamagedBySpell(Mobile caster)
+    {
+      if (caster == this)
+        return;
+
+      SpawnOrcLord(caster);
+    }
+
+    public void SpawnOrcLord(Mobile target)
+    {
+      Map map = target.Map;
+
+      if (map == null)
+        return;
+
+      IPooledEnumerable<OrcishLord> eable = GetMobilesInRange<OrcishLord>(10);
+
+      if (eable.Count() < 10)
+      {
+        BaseCreature orc = new SpawnedOrcishLord{ Team = Team };
+
+        orc.MoveToWorld(map.GetRandomNearbyLocation(target.Location), map);
+        orc.Combatant = target;
+      }
+
+      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/Melee/OrcCaptain.cs

@@ -0,0 +1,131 @@
+using Server.Items;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+  public class OrcCaptain : BaseCreature
+  {
+    [Constructible]
+    public OrcCaptain() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("orc");
+      Body = 7;
+      BaseSoundID = 0x45A;
+
+      SetStr(111, 145);
+      SetDex(101, 135);
+      SetInt(86, 110);
+
+      SetHits(67, 87);
+
+      SetDamage(5, 15);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 30, 35);
+      SetResistance(ResistanceType.Fire, 10, 20);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 5, 10);
+      SetResistance(ResistanceType.Energy, 5, 10);
+
+      SetSkill(SkillName.MagicResist, 70.1, 85.0);
+      SetSkill(SkillName.Swords, 70.1, 95.0);
+      SetSkill(SkillName.Tactics, 85.1, 100.0);
+
+      Fame = 2500;
+      Karma = -2500;
+
+      VirtualArmor = 34;
+
+      // TODO: Skull?
+      switch (Utility.Random(7))
+      {
+        case 0:
+          PackItem(new Arrow());
+          break;
+        case 1:
+          PackItem(new Lockpick());
+          break;
+        case 2:
+          PackItem(new Shaft());
+          break;
+        case 3:
+          PackItem(new Ribs());
+          break;
+        case 4:
+          PackItem(new Bandage());
+          break;
+        case 5:
+          PackItem(new BeverageBottle(BeverageType.Wine));
+          break;
+        case 6:
+          PackItem(new Jug(BeverageType.Cider));
+          break;
+      }
+
+      if (Core.AOS)
+        PackItem(Loot.RandomNecromancyReagent());
+    }
+
+    public OrcCaptain(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an orcish corpse";
+    public override InhumanSpeech SpeechType => InhumanSpeech.Orc;
+
+    public override bool CanRummageCorpses => true;
+    public override int Meat => 1;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.SavagesAndOrcs;
+
+    public override void OnDeath(Container c)
+    {
+      base.OnDeath(c);
+
+      // TODO: Check drop rate
+      if (Utility.RandomDouble() < 0.05)
+        c.DropItem(new StoutWhip());
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager, 2);
+    }
+
+    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/Melee/OrcishLord.cs

@@ -0,0 +1,123 @@
+using Server.Items;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+  public class OrcishLord : BaseCreature
+  {
+    [Constructible]
+    public OrcishLord() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 138;
+      BaseSoundID = 0x45A;
+
+      SetStr(147, 215);
+      SetDex(91, 115);
+      SetInt(61, 85);
+
+      SetHits(95, 123);
+
+      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.MagicResist, 70.1, 85.0);
+      SetSkill(SkillName.Swords, 60.1, 85.0);
+      SetSkill(SkillName.Tactics, 75.1, 90.0);
+      SetSkill(SkillName.Wrestling, 60.1, 85.0);
+
+      Fame = 2500;
+      Karma = -2500;
+
+      switch (Utility.Random(5))
+      {
+        case 0:
+          PackItem(new Lockpick());
+          break;
+        case 1:
+          PackItem(new MortarPestle());
+          break;
+        case 2:
+          PackItem(new Bottle());
+          break;
+        case 3:
+          PackItem(new RawRibs());
+          break;
+        case 4:
+          PackItem(new Shovel());
+          break;
+      }
+
+      PackItem(new RingmailChest());
+
+      if (0.3 > Utility.RandomDouble())
+        PackItem(Loot.RandomPossibleReagent());
+
+      if (0.2 > Utility.RandomDouble())
+        PackItem(new BolaBall());
+    }
+
+    public OrcishLord(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an orcish corpse";
+    public override InhumanSpeech SpeechType => InhumanSpeech.Orc;
+
+    public override string DefaultName => "an orcish lord";
+
+    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.Meager);
+      AddLoot(LootPack.Average);
+      // TODO: evil orc helm
+    }
+
+    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/Melee/Ratman.cs

@@ -0,0 +1,69 @@
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+  public class Ratman : BaseCreature
+  {
+    [Constructible]
+    public Ratman() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("ratman");
+      Body = 42;
+      BaseSoundID = 437;
+
+      SetStr(96, 120);
+      SetDex(81, 100);
+      SetInt(36, 60);
+
+      SetHits(58, 72);
+
+      SetDamage(4, 5);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 25, 30);
+      SetResistance(ResistanceType.Fire, 10, 20);
+      SetResistance(ResistanceType.Cold, 10, 20);
+      SetResistance(ResistanceType.Poison, 10, 20);
+      SetResistance(ResistanceType.Energy, 10, 20);
+
+      SetSkill(SkillName.MagicResist, 35.1, 60.0);
+      SetSkill(SkillName.Tactics, 50.1, 75.0);
+      SetSkill(SkillName.Wrestling, 50.1, 75.0);
+
+      Fame = 1500;
+      Karma = -1500;
+
+      VirtualArmor = 28;
+    }
+
+    public Ratman(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a ratman's corpse";
+    public override InhumanSpeech SpeechType => InhumanSpeech.Ratman;
+
+    public override bool CanRummageCorpses => true;
+    public override int Hides => 8;
+    public override HideType HideType => HideType.Spined;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+      // TODO: weapon, misc
+    }
+
+    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/RatmanArcher.cs

@@ -0,0 +1,80 @@
+using Server.Items;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+  public class RatmanArcher : BaseCreature
+  {
+    [Constructible]
+    public RatmanArcher() : base(AIType.AI_Archer, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("ratman");
+      Body = 0x8E;
+      BaseSoundID = 437;
+
+      SetStr(146, 180);
+      SetDex(101, 130);
+      SetInt(116, 140);
+
+      SetHits(88, 108);
+
+      SetDamage(4, 10);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 40, 55);
+      SetResistance(ResistanceType.Fire, 10, 20);
+      SetResistance(ResistanceType.Cold, 10, 20);
+      SetResistance(ResistanceType.Poison, 10, 20);
+      SetResistance(ResistanceType.Energy, 10, 20);
+
+      SetSkill(SkillName.Anatomy, 60.2, 100.0);
+      SetSkill(SkillName.Archery, 80.1, 90.0);
+      SetSkill(SkillName.MagicResist, 65.1, 90.0);
+      SetSkill(SkillName.Tactics, 50.1, 75.0);
+      SetSkill(SkillName.Wrestling, 50.1, 75.0);
+
+      Fame = 6500;
+      Karma = -6500;
+
+      VirtualArmor = 56;
+
+      AddItem(new Bow());
+      PackItem(new Arrow(Utility.RandomMinMax(50, 70)));
+    }
+
+    public RatmanArcher(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a ratman archer corpse";
+    public override InhumanSpeech SpeechType => InhumanSpeech.Ratman;
+
+    public override bool CanRummageCorpses => true;
+    public override int Hides => 8;
+    public override HideType HideType => HideType.Spined;
+
+    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();
+
+      if (Body == 42)
+      {
+        Body = 0x8E;
+        Hue = 0;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,111 @@
+using System.Collections.Generic;
+using Server.ContextMenus;
+using Server.Engines.Quests;
+using Server.Engines.Quests.Haven;
+
+namespace Server.Mobiles
+{
+  public class RestlessSoul : BaseCreature
+  {
+    [Constructible]
+    public RestlessSoul() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.4, 0.8)
+    {
+      Body = 0x3CA;
+      Hue = 0x453;
+
+      SetStr(26, 40);
+      SetDex(26, 40);
+      SetInt(26, 40);
+
+      SetHits(16, 24);
+
+      SetDamage(1, 10);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 15, 25);
+      SetResistance(ResistanceType.Fire, 5, 15);
+      SetResistance(ResistanceType.Cold, 25, 40);
+      SetResistance(ResistanceType.Poison, 5, 10);
+      SetResistance(ResistanceType.Energy, 10, 20);
+
+      SetSkill(SkillName.MagicResist, 20.1, 30.0);
+      SetSkill(SkillName.Swords, 20.1, 30.0);
+      SetSkill(SkillName.Tactics, 20.1, 30.0);
+      SetSkill(SkillName.Wrestling, 20.1, 30.0);
+
+      Fame = 500;
+      Karma = -500;
+
+      VirtualArmor = 6;
+    }
+
+    public RestlessSoul(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a ghostly corpse";
+    public override string DefaultName => "a restless soul";
+
+    public override bool AlwaysAttackable => true;
+    public override bool BleedImmune => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Poor);
+    }
+
+    public override void DisplayPaperdollTo(Mobile to)
+    {
+    }
+
+    public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
+    {
+      base.GetContextMenuEntries(from, list);
+
+      for (int i = 0; i < list.Count; ++i)
+        if (list[i] is PaperdollEntry)
+          list.RemoveAt(i--);
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x107;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x1BF;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0xFD;
+    }
+
+    public override bool IsEnemy(Mobile m)
+    {
+      if (m is PlayerMobile player && Map == Map.Trammel && X >= 5199 && X <= 5271 && Y >= 1812 && Y <= 1865
+      ) // Schmendrick's cave
+      {
+        QuestSystem qs = player.Quest;
+
+        if (qs is UzeraanTurmoilQuest && qs.IsObjectiveInProgress(typeof(FindSchmendrickObjective))) return false;
+      }
+
+      return base.IsEnemy(m);
+    }
+
+    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/RottingCorpse.cs

@@ -0,0 +1,73 @@
+namespace Server.Mobiles
+{
+  public class RottingCorpse : BaseCreature
+  {
+    [Constructible]
+    public RottingCorpse() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 155;
+      BaseSoundID = 471;
+
+      SetStr(301, 350);
+      SetDex(75);
+      SetInt(151, 200);
+
+      SetHits(1200);
+      SetStam(150);
+      SetMana(0);
+
+      SetDamage(8, 10);
+
+      SetDamageType(ResistanceType.Physical, 0);
+      SetDamageType(ResistanceType.Cold, 50);
+      SetDamageType(ResistanceType.Poison, 50);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 50, 70);
+      SetResistance(ResistanceType.Poison, 40, 50);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.Poisoning, 120.0);
+      SetSkill(SkillName.MagicResist, 250.0);
+      SetSkill(SkillName.Tactics, 100.0);
+      SetSkill(SkillName.Wrestling, 90.1, 100.0);
+
+      Fame = 6000;
+      Karma = -6000;
+
+      VirtualArmor = 40;
+    }
+
+    public RottingCorpse(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a rotting corpse";
+    public override string DefaultName => "a rotting corpse";
+
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override Poison HitPoison => Poison.Lethal;
+    public override int TreasureMapLevel => 5;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    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/Humanoid/Melee/Savage.cs

@@ -0,0 +1,115 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Savage : BaseCreature
+  {
+    [Constructible]
+    public Savage() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Name = NameList.RandomName("savage");
+
+      if (Female = Utility.RandomBool())
+        Body = 184;
+      else
+        Body = 183;
+
+      SetStr(96, 115);
+      SetDex(86, 105);
+      SetInt(51, 65);
+
+      SetDamage(23, 27);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetSkill(SkillName.Fencing, 60.0, 82.5);
+      SetSkill(SkillName.Macing, 60.0, 82.5);
+      SetSkill(SkillName.Poisoning, 60.0, 82.5);
+      SetSkill(SkillName.MagicResist, 57.5, 80.0);
+      SetSkill(SkillName.Swords, 60.0, 82.5);
+      SetSkill(SkillName.Tactics, 60.0, 82.5);
+
+      Fame = 1000;
+      Karma = -1000;
+
+      PackItem(new Bandage(Utility.RandomMinMax(1, 15)));
+
+      if (Female && 0.1 > Utility.RandomDouble())
+        PackItem(new TribalBerry());
+      else if (!Female && 0.1 > Utility.RandomDouble())
+        PackItem(new BolaBall());
+
+      AddItem(new Spear());
+      AddItem(new BoneArms());
+      AddItem(new BoneLegs());
+
+      if (0.5 > Utility.RandomDouble())
+        AddItem(new SavageMask());
+      else if (0.1 > Utility.RandomDouble())
+        AddItem(new OrcishKinMask());
+    }
+
+    public Savage(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.Meager);
+    }
+
+    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 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/SavageRider.cs

@@ -0,0 +1,125 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class SavageRider : BaseCreature
+  {
+    [Constructible]
+    public SavageRider() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.15, 0.4)
+    {
+      Name = NameList.RandomName("savage rider");
+
+      if (Female = Utility.RandomBool())
+        Body = 186;
+      else
+        Body = 185;
+
+      SetStr(151, 170);
+      SetDex(92, 130);
+      SetInt(51, 65);
+
+      SetDamage(29, 34);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetSkill(SkillName.Fencing, 72.5, 95.0);
+      SetSkill(SkillName.Healing, 60.3, 90.0);
+      SetSkill(SkillName.Macing, 72.5, 95.0);
+      SetSkill(SkillName.Poisoning, 60.0, 82.5);
+      SetSkill(SkillName.MagicResist, 72.5, 95.0);
+      SetSkill(SkillName.Swords, 72.5, 95.0);
+      SetSkill(SkillName.Tactics, 72.5, 95.0);
+
+      Fame = 1000;
+      Karma = -1000;
+
+      PackItem(new Bandage(Utility.RandomMinMax(1, 15)));
+
+      if (0.1 > Utility.RandomDouble())
+        PackItem(new BolaBall());
+
+      AddItem(new TribalSpear());
+      AddItem(new BoneArms());
+      AddItem(new BoneLegs());
+      // TODO: BEAR MASK
+
+      new SavageRidgeback().Rider = this;
+    }
+
+    public SavageRider(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 OnBeforeDeath()
+    {
+      IMount mount = Mount;
+
+      if (mount != null)
+        mount.Rider = null;
+
+      if (mount is Mobile mobile)
+        mobile.Delete();
+
+      return base.OnBeforeDeath();
+    }
+
+    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 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/ShadowFiend.cs

@@ -0,0 +1,141 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class ShadowFiend : BaseCreature
+  {
+    private UnhideTimer m_Timer;
+
+    [Constructible]
+    public ShadowFiend() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0xA8;
+
+      // this to allow shadow fiend to loot from corpses
+      Backpack backpack = new Backpack();
+      backpack.Movable = false;
+      AddItem(backpack);
+
+      SetStr(46, 55);
+      SetDex(121, 130);
+      SetInt(46, 55);
+
+      SetHits(28, 33);
+      SetStam(46, 55);
+
+      SetDamage(10, 22);
+
+      SetDamageType(ResistanceType.Physical, 20);
+      SetDamageType(ResistanceType.Cold, 80);
+
+      SetResistance(ResistanceType.Physical, 20, 25);
+      SetResistance(ResistanceType.Fire, 20, 25);
+      SetResistance(ResistanceType.Cold, 40, 45);
+      SetResistance(ResistanceType.Poison, 60, 70);
+      SetResistance(ResistanceType.Energy, 5, 10);
+
+      SetSkill(SkillName.MagicResist, 20.1, 30.0);
+      SetSkill(SkillName.Tactics, 20.1, 30.0);
+      SetSkill(SkillName.Wrestling, 20.1, 30.0);
+
+      Fame = 1000;
+      Karma = -1000;
+
+      m_Timer = new UnhideTimer(this);
+      m_Timer.Start();
+    }
+
+    public ShadowFiend(Serial serial) : base(serial)
+    {
+    }
+
+    public override bool DeleteCorpseOnDeath => true;
+
+    public override string DefaultName => "a shadow fiend";
+
+    public override bool CanRummageCorpses => true;
+
+    public override int GetIdleSound()
+    {
+      return 0x37A;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x379;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x381;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x37F;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x380;
+    }
+
+    public override bool OnBeforeDeath()
+    {
+      Backpack?.Destroy();
+
+      Effects.SendLocationEffect(Location, Map, 0x376A, 10, 1);
+      return true;
+    }
+
+    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();
+
+      m_Timer = new UnhideTimer(this);
+      m_Timer.Start();
+    }
+
+    public override void OnAfterDelete()
+    {
+      m_Timer?.Stop();
+
+      m_Timer = null;
+
+      base.OnAfterDelete();
+    }
+
+    private class UnhideTimer : Timer
+    {
+      private ShadowFiend m_Owner;
+
+      public UnhideTimer(ShadowFiend owner) : base(TimeSpan.FromSeconds(30.0))
+      {
+        m_Owner = owner;
+        Priority = TimerPriority.OneSecond;
+      }
+
+      protected override void OnTick()
+      {
+        if (m_Owner.Deleted)
+        {
+          Stop();
+          return;
+        }
+
+        foreach (Mobile m in m_Owner.GetMobilesInRange(3))
+          if (m != m_Owner && m.Player && m.Hidden && m_Owner.CanBeHarmful(m) &&
+              m.AccessLevel == AccessLevel.Player)
+            m.Hidden = false;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,94 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class SkeletalKnight : BaseCreature
+  {
+    [Constructible]
+    public SkeletalKnight() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 147;
+      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;
+      }
+
+      PackItem(new Scimitar());
+      PackItem(new WoodenShield());
+    }
+
+    public SkeletalKnight(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a skeletal corpse";
+    public override string DefaultName => "a skeletal 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/Skeleton.cs

@@ -0,0 +1,87 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Skeleton : BaseCreature
+  {
+    [Constructible]
+    public Skeleton() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = Utility.RandomList(50, 56);
+      BaseSoundID = 0x48D;
+
+      SetStr(56, 80);
+      SetDex(56, 75);
+      SetInt(16, 40);
+
+      SetHits(34, 48);
+
+      SetDamage(3, 7);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 15, 20);
+      SetResistance(ResistanceType.Fire, 5, 10);
+      SetResistance(ResistanceType.Cold, 25, 40);
+      SetResistance(ResistanceType.Poison, 25, 35);
+      SetResistance(ResistanceType.Energy, 5, 15);
+
+      SetSkill(SkillName.MagicResist, 45.1, 60.0);
+      SetSkill(SkillName.Tactics, 45.1, 60.0);
+      SetSkill(SkillName.Wrestling, 45.1, 55.0);
+
+      Fame = 450;
+      Karma = -450;
+
+      VirtualArmor = 16;
+
+      switch (Utility.Random(5))
+      {
+        case 0:
+          PackItem(new BoneArms());
+          break;
+        case 1:
+          PackItem(new BoneChest());
+          break;
+        case 2:
+          PackItem(new BoneGloves());
+          break;
+        case 3:
+          PackItem(new BoneLegs());
+          break;
+        case 4:
+          PackItem(new BoneHelm());
+          break;
+      }
+    }
+
+    public Skeleton(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a skeletal corpse";
+    public override string DefaultName => "a skeleton";
+
+    public override bool BleedImmune => true;
+    public override Poison PoisonImmune => Poison.Lesser;
+
+    public override OppositionGroup OppositionGroup => OppositionGroup.FeyAndUndead;
+
+    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/SpawnedOrcishLord.cs

@@ -0,0 +1,43 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class SpawnedOrcishLord : OrcishLord
+  {
+    [Constructible]
+    public SpawnedOrcishLord()
+    {
+      Container pack = Backpack;
+
+      pack?.Delete();
+
+      NoKillAwards = true;
+    }
+
+    public SpawnedOrcishLord(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an orcish corpse";
+
+    public override void OnDeath(Container c)
+    {
+      base.OnDeath(c);
+
+      c.Delete();
+    }
+
+    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();
+      NoKillAwards = true;
+    }
+  }
+}

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

@@ -0,0 +1,97 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class SpectralArmour : BaseCreature
+  {
+    [Constructible]
+    public SpectralArmour() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 637;
+      Hue = 0x8026;
+
+      Buckler buckler = new Buckler();
+      ChainCoif coif = new ChainCoif();
+      PlateGloves gloves = new PlateGloves();
+
+      buckler.Hue = 0x835;
+      buckler.Movable = false;
+      coif.Hue = 0x835;
+      gloves.Hue = 0x835;
+
+      AddItem(buckler);
+      AddItem(coif);
+      AddItem(gloves);
+
+      SetStr(101, 110);
+      SetDex(101, 110);
+      SetInt(101, 110);
+
+      SetHits(178, 201);
+      SetStam(191, 200);
+
+      SetDamage(10, 22);
+
+      SetDamageType(ResistanceType.Physical, 75);
+      SetDamageType(ResistanceType.Cold, 25);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 30, 40);
+      SetResistance(ResistanceType.Poison, 20, 30);
+      SetResistance(ResistanceType.Energy, 20, 30);
+
+      SetSkill(SkillName.Wrestling, 75.1, 100.0);
+      SetSkill(SkillName.Tactics, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 90.1, 100);
+
+      VirtualArmor = 40;
+      Fame = 7000;
+      Karma = -7000;
+    }
+
+    public SpectralArmour(Serial serial) : base(serial)
+    {
+    }
+
+    public override bool DeleteCorpseOnDeath => true;
+
+    public override string DefaultName => "a spectral armour";
+
+    public override Poison PoisonImmune => Poison.Regular;
+
+    public override int GetIdleSound()
+    {
+      return 0x200;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x56;
+    }
+
+    public override bool OnBeforeDeath()
+    {
+      if (!base.OnBeforeDeath())
+        return false;
+
+      Gold gold = new Gold(Utility.RandomMinMax(240, 375));
+      gold.MoveToWorld(Location, Map);
+
+      Effects.SendLocationEffect(Location, Map, 0x376A, 10, 1);
+      return true;
+    }
+
+    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/StoneGargoyle.cs

@@ -0,0 +1,72 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class StoneGargoyle : BaseCreature
+  {
+    [Constructible]
+    public StoneGargoyle() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 67;
+      BaseSoundID = 0x174;
+
+      SetStr(246, 275);
+      SetDex(76, 95);
+      SetInt(81, 105);
+
+      SetHits(148, 165);
+
+      SetDamage(11, 17);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 20, 30);
+      SetResistance(ResistanceType.Cold, 10, 20);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.MagicResist, 85.1, 100.0);
+      SetSkill(SkillName.Tactics, 80.1, 100.0);
+      SetSkill(SkillName.Wrestling, 60.1, 100.0);
+
+      Fame = 4000;
+      Karma = -4000;
+
+      VirtualArmor = 50;
+
+      PackItem(new IronIngot(12));
+
+      if (0.05 > Utility.RandomDouble())
+        PackItem(new GargoylesPickaxe());
+    }
+
+    public StoneGargoyle(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a gargoyle corpse";
+    public override string DefaultName => "a stone gargoyle";
+
+    public override int TreasureMapLevel => 2;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average, 2);
+      AddLoot(LootPack.Gems, 1);
+      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/StrongMongbat.cs

@@ -0,0 +1,66 @@
+namespace Server.Mobiles
+{
+  public class StrongMongbat : BaseCreature
+  {
+    [Constructible]
+    public StrongMongbat() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 39;
+      BaseSoundID = 422;
+
+      SetStr(6, 10);
+      SetDex(26, 38);
+      SetInt(6, 14);
+
+      SetHits(4, 6);
+      SetMana(0);
+
+      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 = 150;
+      Karma = -150;
+
+      VirtualArmor = 10;
+
+      Tamable = true;
+      ControlSlots = 1;
+      MinTameSkill = 71.1;
+    }
+
+    public StrongMongbat(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a mongbat corpse";
+    public override string DefaultName => "a 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/Troll.cs

@@ -0,0 +1,65 @@
+namespace Server.Mobiles
+{
+  public class Troll : BaseCreature
+  {
+    [Constructible]
+    public Troll() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = Utility.RandomList(53, 54);
+      BaseSoundID = 461;
+
+      SetStr(176, 205);
+      SetDex(46, 65);
+      SetInt(46, 70);
+
+      SetHits(106, 123);
+
+      SetDamage(8, 14);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 25, 35);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 5, 15);
+      SetResistance(ResistanceType.Energy, 5, 15);
+
+      SetSkill(SkillName.MagicResist, 45.1, 60.0);
+      SetSkill(SkillName.Tactics, 50.1, 70.0);
+      SetSkill(SkillName.Wrestling, 50.1, 70.0);
+
+      Fame = 3500;
+      Karma = -3500;
+
+      VirtualArmor = 40;
+    }
+
+    public Troll(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a troll corpse";
+    public override string DefaultName => "a troll";
+
+    public override bool CanRummageCorpses => true;
+    public override int TreasureMapLevel => 1;
+    public override int Meat => 2;
+
+    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/Zombie.cs

@@ -0,0 +1,100 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class Zombie : BaseCreature
+  {
+    [Constructible]
+    public Zombie() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 3;
+      BaseSoundID = 471;
+
+      SetStr(46, 70);
+      SetDex(31, 50);
+      SetInt(26, 40);
+
+      SetHits(28, 42);
+
+      SetDamage(3, 7);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 15, 20);
+      SetResistance(ResistanceType.Cold, 20, 30);
+      SetResistance(ResistanceType.Poison, 5, 10);
+
+      SetSkill(SkillName.MagicResist, 15.1, 40.0);
+      SetSkill(SkillName.Tactics, 35.1, 50.0);
+      SetSkill(SkillName.Wrestling, 35.1, 50.0);
+
+      Fame = 600;
+      Karma = -600;
+
+      VirtualArmor = 18;
+
+      switch (Utility.Random(10))
+      {
+        case 0:
+          PackItem(new LeftArm());
+          break;
+        case 1:
+          PackItem(new RightArm());
+          break;
+        case 2:
+          PackItem(new Torso());
+          break;
+        case 3:
+          PackItem(new Bone());
+          break;
+        case 4:
+          PackItem(new RibCage());
+          break;
+        case 5:
+          PackItem(new RibCage());
+          break;
+        case 6:
+          PackItem(new BonePile());
+          break;
+        case 7:
+          PackItem(new BonePile());
+          break;
+        case 8:
+          PackItem(new BonePile());
+          break;
+        case 9:
+          PackItem(new BonePile());
+          break;
+      }
+    }
+
+    public Zombie(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a rotting corpse";
+    public override string DefaultName => "a zombie";
+
+    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();
+    }
+  }
+}