Reorganizes Project (#41)

Projects/Scripts/Mobiles/Monsters/LBR/Exodus/ExodusMinion.cs

@@ -0,0 +1,195 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class ExodusMinion : BaseCreature
+  {
+    [Constructible]
+    public ExodusMinion() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0x2F5;
+
+      SetStr(851, 950);
+      SetDex(71, 80);
+      SetInt(61, 90);
+
+      SetHits(511, 570);
+
+      SetDamage(16, 22);
+
+      SetResistance(ResistanceType.Physical, 60, 70);
+      SetResistance(ResistanceType.Fire, 40, 50);
+      SetResistance(ResistanceType.Cold, 15, 25);
+      SetResistance(ResistanceType.Poison, 15, 25);
+      SetResistance(ResistanceType.Energy, 15, 25);
+
+      SetSkill(SkillName.MagicResist, 90.1, 100.0);
+      SetSkill(SkillName.Tactics, 90.1, 100.0);
+      SetSkill(SkillName.Wrestling, 90.1, 100.0);
+
+      Fame = 18000;
+      Karma = -18000;
+      VirtualArmor = 65;
+
+      PackItem(new PowerCrystal());
+      PackItem(new ArcaneGem());
+      PackItem(new ClockworkAssembly());
+
+      switch (Utility.Random(3))
+      {
+        case 0:
+          PackItem(new PowerCrystal());
+          break;
+        case 1:
+          PackItem(new ArcaneGem());
+          break;
+        case 2:
+          PackItem(new ClockworkAssembly());
+          break;
+      }
+
+      FieldActive = CanUseField;
+    }
+
+    public ExodusMinion(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a minion's corpse";
+    public bool FieldActive{ get; private set; }
+
+    public bool CanUseField // TODO: an OSI bug prevents to verify this
+      => Hits >= HitsMax * 9 / 10;
+
+    public override bool IsScaredOfScaryThings => false;
+    public override bool IsScaryToPets => true;
+
+    public override string DefaultName => "an exodus minion";
+
+    public override bool AutoDispel => true;
+    public override bool BardImmune => !Core.AOS;
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Rich);
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x218;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x26C;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x211;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x232;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x140;
+    }
+
+    public override void AlterMeleeDamageFrom(Mobile from, ref int damage)
+    {
+      if (FieldActive)
+        damage = 0; // no melee damage when the field is up
+    }
+
+    public override void AlterSpellDamageFrom(Mobile from, ref int damage)
+    {
+      if (!FieldActive)
+        damage = 0; // no spell damage when the field is down
+    }
+
+    public override void OnDamagedBySpell(Mobile from)
+    {
+      if (from?.Alive == true && 0.4 > Utility.RandomDouble()) SendEBolt(from);
+
+      if (!FieldActive)
+      {
+        // should there be an effect when spells nullifying is on?
+        FixedParticles(0, 10, 0, 0x2522, EffectLayer.Waist);
+      }
+      else if (FieldActive && !CanUseField)
+      {
+        FieldActive = false;
+
+        // TODO: message and effect when field turns down; cannot be verified on OSI due to a bug
+        FixedParticles(0x3735, 1, 30, 0x251F, EffectLayer.Waist);
+      }
+    }
+
+    public override void OnGotMeleeAttack(Mobile attacker)
+    {
+      base.OnGotMeleeAttack(attacker);
+
+      if (FieldActive)
+      {
+        FixedParticles(0x376A, 20, 10, 0x2530, EffectLayer.Waist);
+
+        PlaySound(0x2F4);
+
+        attacker.SendAsciiMessage("Your weapon cannot penetrate the creature's magical barrier");
+      }
+
+      if (attacker?.Alive == true && attacker.Weapon is BaseRanged && 0.4 > Utility.RandomDouble())
+        SendEBolt(attacker);
+    }
+
+    public override void OnThink()
+    {
+      base.OnThink();
+
+      // TODO: an OSI bug prevents to verify if the field can regenerate or not
+      if (!FieldActive && !IsHurt())
+        FieldActive = true;
+    }
+
+    public override bool Move(Direction d)
+    {
+      bool move = base.Move(d);
+
+      if (move && FieldActive && Combatant != null)
+        FixedParticles(0, 10, 0, 0x2530, EffectLayer.Waist);
+
+      return move;
+    }
+
+    public void SendEBolt(Mobile to)
+    {
+      MovingParticles(to, 0x379F, 7, 0, false, true, 0xBE3, 0xFCB, 0x211);
+      to.PlaySound(0x229);
+      DoHarmful(to);
+      AOS.Damage(to, this, 50, 0, 0, 0, 0, 100);
+    }
+
+    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();
+
+      FieldActive = CanUseField;
+
+      if (Name == "Exodus Minion")
+        Name = null;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/LBR/Exodus/ExodusOverseer.cs

@@ -0,0 +1,185 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class ExodusOverseer : BaseCreature
+  {
+    [Constructible]
+    public ExodusOverseer() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 0x2F4;
+
+      SetStr(561, 650);
+      SetDex(76, 95);
+      SetInt(61, 90);
+
+      SetHits(331, 390);
+
+      SetDamage(13, 19);
+
+      SetDamageType(ResistanceType.Physical, 50);
+      SetDamageType(ResistanceType.Energy, 50);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 40, 60);
+      SetResistance(ResistanceType.Cold, 25, 35);
+      SetResistance(ResistanceType.Poison, 25, 35);
+      SetResistance(ResistanceType.Energy, 25, 35);
+
+      SetSkill(SkillName.MagicResist, 80.2, 98.0);
+      SetSkill(SkillName.Tactics, 80.2, 98.0);
+      SetSkill(SkillName.Wrestling, 80.2, 98.0);
+
+      Fame = 10000;
+      Karma = -10000;
+      VirtualArmor = 50;
+
+      if (Utility.Random(2) == 0)
+        PackItem(new PowerCrystal());
+      else
+        PackItem(new ArcaneGem());
+
+      FieldActive = CanUseField;
+    }
+
+    public ExodusOverseer(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an overseer's corpse";
+    public bool FieldActive{ get; private set; }
+
+    public bool CanUseField // TODO: an OSI bug prevents to verify this
+      => Hits >= HitsMax * 9 / 10;
+
+    public override bool IsScaredOfScaryThings => false;
+    public override bool IsScaryToPets => true;
+
+    public override string DefaultName => "an exodus overseer";
+
+    public override bool AutoDispel => true;
+    public override bool BardImmune => !Core.AOS;
+    public override Poison PoisonImmune => Poison.Lethal;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0xFD;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x26C;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x211;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x23B;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x140;
+    }
+
+    public override void AlterMeleeDamageFrom(Mobile from, ref int damage)
+    {
+      if (FieldActive)
+        damage = 0; // no melee damage when the field is up
+    }
+
+    public override void AlterSpellDamageFrom(Mobile caster, ref int damage)
+    {
+      if (!FieldActive)
+        damage = 0; // no spell damage when the field is down
+    }
+
+    public override void OnDamagedBySpell(Mobile from)
+    {
+      if (from?.Alive == true && 0.4 > Utility.RandomDouble()) SendEBolt(from);
+
+      if (!FieldActive)
+      {
+        // should there be an effect when spells nullifying is on?
+        FixedParticles(0, 10, 0, 0x2522, EffectLayer.Waist);
+      }
+      else if (FieldActive && !CanUseField)
+      {
+        FieldActive = false;
+
+        // TODO: message and effect when field turns down; cannot be verified on OSI due to a bug
+        FixedParticles(0x3735, 1, 30, 0x251F, EffectLayer.Waist);
+      }
+    }
+
+    public override void OnGotMeleeAttack(Mobile attacker)
+    {
+      base.OnGotMeleeAttack(attacker);
+
+      if (FieldActive)
+      {
+        FixedParticles(0x376A, 20, 10, 0x2530, EffectLayer.Waist);
+
+        PlaySound(0x2F4);
+
+        attacker.SendAsciiMessage("Your weapon cannot penetrate the creature's magical barrier");
+      }
+
+      if (attacker?.Alive == true && attacker.Weapon is BaseRanged && 0.4 > Utility.RandomDouble())
+        SendEBolt(attacker);
+    }
+
+    public override void OnThink()
+    {
+      base.OnThink();
+
+      // TODO: an OSI bug prevents to verify if the field can regenerate or not
+      if (!FieldActive && !IsHurt())
+        FieldActive = true;
+    }
+
+    public override bool Move(Direction d)
+    {
+      bool move = base.Move(d);
+
+      if (move && FieldActive && Combatant != null)
+        FixedParticles(0, 10, 0, 0x2530, EffectLayer.Waist);
+
+      return move;
+    }
+
+    public void SendEBolt(Mobile to)
+    {
+      MovingParticles(to, 0x379F, 7, 0, false, true, 0xBE3, 0xFCB, 0x211);
+      to.PlaySound(0x229);
+      DoHarmful(to);
+      AOS.Damage(to, this, 50, 0, 0, 0, 0, 100);
+    }
+
+    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();
+
+      FieldActive = CanUseField;
+
+      if (Name == "Exodus Overseer")
+        Name = null;
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/LBR/Jukas/ChaosDragoon.cs

@@ -0,0 +1,213 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class ChaosDragoon : BaseCreature
+  {
+    [Constructible]
+    public ChaosDragoon() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.15, 0.4)
+    {
+      Body = 0x190;
+      Hue = Race.Human.RandomSkinHue();
+
+      SetStr(176, 225);
+      SetDex(81, 95);
+      SetInt(61, 85);
+
+      SetHits(176, 225);
+
+      SetDamage(24, 26);
+
+      SetDamageType(ResistanceType.Physical, 25);
+      SetDamageType(ResistanceType.Fire, 25);
+      SetDamageType(ResistanceType.Cold, 25);
+      SetDamageType(ResistanceType.Energy, 25);
+
+      //SetResistance( ResistanceType.Physical, 25, 38 );
+      //SetResistance( ResistanceType.Fire, 25, 38 );
+      //SetResistance( ResistanceType.Cold, 25, 38 );
+      //SetResistance( ResistanceType.Poison, 25, 38 );
+      //SetResistance( ResistanceType.Energy, 25, 38 );
+
+      SetSkill(SkillName.Fencing, 77.6, 92.5);
+      SetSkill(SkillName.Healing, 60.3, 90.0);
+      SetSkill(SkillName.Macing, 77.6, 92.5);
+      SetSkill(SkillName.Anatomy, 77.6, 87.5);
+      SetSkill(SkillName.MagicResist, 77.6, 97.5);
+      SetSkill(SkillName.Swords, 77.6, 92.5);
+      SetSkill(SkillName.Tactics, 77.6, 87.5);
+
+      Fame = 5000;
+      Karma = -5000;
+
+      CraftResource res = CraftResource.None;
+
+      switch (Utility.Random(6))
+      {
+        case 0:
+          res = CraftResource.BlackScales;
+          break;
+        case 1:
+          res = CraftResource.RedScales;
+          break;
+        case 2:
+          res = CraftResource.BlueScales;
+          break;
+        case 3:
+          res = CraftResource.YellowScales;
+          break;
+        case 4:
+          res = CraftResource.GreenScales;
+          break;
+        case 5:
+          res = CraftResource.WhiteScales;
+          break;
+      }
+
+      BaseWeapon melee = null;
+
+      switch (Utility.Random(3))
+      {
+        case 0:
+          melee = new Kryss();
+          break;
+        case 1:
+          melee = new Broadsword();
+          break;
+        case 2:
+          melee = new Katana();
+          break;
+      }
+
+      melee.Movable = false;
+      AddItem(melee);
+
+      DragonHelm helm = new DragonHelm();
+      helm.Resource = res;
+      helm.Movable = false;
+      AddItem(helm);
+
+      DragonChest chest = new DragonChest();
+      chest.Resource = res;
+      chest.Movable = false;
+      AddItem(chest);
+
+      DragonArms arms = new DragonArms();
+      arms.Resource = res;
+      arms.Movable = false;
+      AddItem(arms);
+
+      DragonGloves gloves = new DragonGloves();
+      gloves.Resource = res;
+      gloves.Movable = false;
+      AddItem(gloves);
+
+      DragonLegs legs = new DragonLegs();
+      legs.Resource = res;
+      legs.Movable = false;
+      AddItem(legs);
+
+      ChaosShield shield = new ChaosShield();
+      shield.Movable = false;
+      AddItem(shield);
+
+      AddItem(new Shirt());
+      AddItem(new Boots());
+
+      int amount = Utility.RandomMinMax(1, 3);
+
+      switch (res)
+      {
+        case CraftResource.BlackScales:
+          AddItem(new BlackScales(amount));
+          break;
+        case CraftResource.RedScales:
+          AddItem(new RedScales(amount));
+          break;
+        case CraftResource.BlueScales:
+          AddItem(new BlueScales(amount));
+          break;
+        case CraftResource.YellowScales:
+          AddItem(new YellowScales(amount));
+          break;
+        case CraftResource.GreenScales:
+          AddItem(new GreenScales(amount));
+          break;
+        case CraftResource.WhiteScales:
+          AddItem(new WhiteScales(amount));
+          break;
+      }
+
+      new SwampDragon().Rider = this;
+    }
+
+    public ChaosDragoon(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a chaos dragoon corpse";
+    public override string DefaultName => "a chaos dragoon";
+
+    public override bool HasBreath => true;
+    public override bool AutoDispel => true;
+    public override bool BardImmune => !Core.AOS;
+    public override bool CanRummageCorpses => true;
+    public override bool AlwaysMurderer => true;
+    public override bool ShowFameTitle => false;
+
+    public override int GetIdleSound()
+    {
+      return 0x2CE;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x2CC;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x2D1;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x2C8;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      //AddLoot( LootPack.Gems );
+    }
+
+    public override bool OnBeforeDeath()
+    {
+      IMount mount = Mount;
+
+      if (mount != null)
+        mount.Rider = null;
+
+      return base.OnBeforeDeath();
+    }
+
+    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/LBR/Jukas/ChaosDragoonElite.cs

@@ -0,0 +1,255 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class ChaosDragoonElite : BaseCreature
+  {
+    [Constructible]
+    public ChaosDragoonElite()
+      : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.15, 0.4)
+    {
+      Body = 0x190;
+      Hue = Race.Human.RandomSkinHue();
+
+      SetStr(276, 350);
+      SetDex(66, 90);
+      SetInt(126, 150);
+
+      SetHits(276, 350);
+
+      SetDamage(29, 34);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      /*SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 15, 25);
+      SetResistance(ResistanceType.Cold, 50);
+      SetResistance(ResistanceType.Poison, 25, 35);
+      SetResistance(ResistanceType.Energy, 25, 35);*/
+
+
+      SetSkill(SkillName.Tactics, 80.1, 100.0);
+      SetSkill(SkillName.MagicResist, 100.1, 110.0);
+      SetSkill(SkillName.Anatomy, 80.1, 100.0);
+      SetSkill(SkillName.Magery, 85.1, 100.0);
+      SetSkill(SkillName.EvalInt, 85.1, 100.0);
+      SetSkill(SkillName.Swords, 72.5, 95.0);
+      SetSkill(SkillName.Fencing, 85.1, 100);
+      SetSkill(SkillName.Macing, 85.1, 100);
+
+      Fame = 8000;
+      Karma = -8000;
+
+      CraftResource res = CraftResource.None;
+      ;
+
+      switch (Utility.Random(6))
+      {
+        case 0:
+          res = CraftResource.BlackScales;
+          break;
+        case 1:
+          res = CraftResource.RedScales;
+          break;
+        case 2:
+          res = CraftResource.BlueScales;
+          break;
+        case 3:
+          res = CraftResource.YellowScales;
+          break;
+        case 4:
+          res = CraftResource.GreenScales;
+          break;
+        case 5:
+          res = CraftResource.WhiteScales;
+          break;
+      }
+
+      BaseWeapon melee = null;
+
+      switch (Utility.Random(3))
+      {
+        case 0:
+          melee = new Kryss();
+          break;
+        case 1:
+          melee = new Broadsword();
+          break;
+        case 2:
+          melee = new Katana();
+          break;
+      }
+
+      melee.Movable = false;
+      AddItem(melee);
+
+      DragonChest Tunic = new DragonChest();
+      Tunic.Resource = res;
+      Tunic.Movable = false;
+      AddItem(Tunic);
+
+      DragonLegs Legs = new DragonLegs();
+      Legs.Resource = res;
+      Legs.Movable = false;
+      AddItem(Legs);
+
+      DragonArms Arms = new DragonArms();
+      Arms.Resource = res;
+      Arms.Movable = false;
+      AddItem(Arms);
+
+      DragonGloves Gloves = new DragonGloves();
+      Gloves.Resource = res;
+      Gloves.Movable = false;
+      AddItem(Gloves);
+
+      DragonHelm Helm = new DragonHelm();
+      Helm.Resource = res;
+      Helm.Movable = false;
+      AddItem(Helm);
+
+      ChaosShield shield = new ChaosShield();
+      shield.Movable = false;
+      AddItem(shield);
+
+      AddItem(new Boots(0x455));
+      AddItem(new Shirt(Utility.RandomMetalHue()));
+
+      int amount = Utility.RandomMinMax(1, 3);
+
+      switch (res)
+      {
+        case CraftResource.BlackScales:
+          AddItem(new BlackScales(amount));
+          break;
+        case CraftResource.RedScales:
+          AddItem(new RedScales(amount));
+          break;
+        case CraftResource.BlueScales:
+          AddItem(new BlueScales(amount));
+          break;
+        case CraftResource.YellowScales:
+          AddItem(new YellowScales(amount));
+          break;
+        case CraftResource.GreenScales:
+          AddItem(new GreenScales(amount));
+          break;
+        case CraftResource.WhiteScales:
+          AddItem(new WhiteScales(amount));
+          break;
+      }
+
+      switch (Utility.Random(9))
+      {
+        case 0:
+          res = CraftResource.DullCopper;
+          break;
+        case 1:
+          res = CraftResource.ShadowIron;
+          break;
+        case 2:
+          res = CraftResource.Copper;
+          break;
+        case 3:
+          res = CraftResource.Bronze;
+          break;
+        case 4:
+          res = CraftResource.Gold;
+          break;
+        case 5:
+          res = CraftResource.Agapite;
+          break;
+        case 6:
+          res = CraftResource.Verite;
+          break;
+        case 7:
+          res = CraftResource.Valorite;
+          break;
+        case 8:
+          res = CraftResource.Iron;
+          break;
+      }
+
+      SwampDragon mt = new SwampDragon();
+      mt.HasBarding = true;
+      mt.BardingResource = res;
+      mt.BardingHP = mt.BardingMaxHP;
+      mt.Rider = this;
+    }
+
+    public ChaosDragoonElite(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a chaos dragoon elite corpse";
+    public override string DefaultName => "a chaos dragoon elite";
+
+    public override bool HasBreath => true;
+    public override bool AutoDispel => true;
+    public override bool BardImmune => !Core.AOS;
+    public override bool CanRummageCorpses => true;
+    public override bool AlwaysMurderer => true;
+    public override bool ShowFameTitle => false;
+
+    public override int GetIdleSound()
+    {
+      return 0x2CE;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x2CC;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x2D1;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x2C8;
+    }
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Gems);
+    }
+
+    public override bool OnBeforeDeath()
+    {
+      IMount mount = Mount;
+
+      if (mount != null)
+      {
+        if (mount is SwampDragon dragon)
+          dragon.HasBarding = false;
+
+        mount.Rider = null;
+      }
+
+      return base.OnBeforeDeath();
+    }
+
+    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/LBR/Jukas/JukaLord.cs

@@ -0,0 +1,125 @@
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class JukaLord : BaseCreature
+  {
+    [Constructible]
+    public JukaLord() : base(AIType.AI_Archer, FightMode.Closest, 10, 3, 0.2, 0.4)
+    {
+      Body = 766;
+
+      SetStr(401, 500);
+      SetDex(81, 100);
+      SetInt(151, 200);
+
+      SetHits(241, 300);
+
+      SetDamage(10, 12);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 40, 50);
+      SetResistance(ResistanceType.Fire, 45, 50);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 20, 25);
+      SetResistance(ResistanceType.Energy, 40, 50);
+
+      SetSkill(SkillName.Anatomy, 90.1, 100.0);
+      SetSkill(SkillName.Archery, 95.1, 100.0);
+      SetSkill(SkillName.Healing, 80.1, 100.0);
+      SetSkill(SkillName.MagicResist, 120.1, 130.0);
+      SetSkill(SkillName.Swords, 90.1, 100.0);
+      SetSkill(SkillName.Tactics, 95.1, 100.0);
+      SetSkill(SkillName.Wrestling, 90.1, 100.0);
+
+      Fame = 15000;
+      Karma = -15000;
+
+      VirtualArmor = 28;
+
+      Container pack = new Backpack();
+
+      pack.DropItem(new Arrow(Utility.RandomMinMax(25, 35)));
+      pack.DropItem(new Arrow(Utility.RandomMinMax(25, 35)));
+      pack.DropItem(new Bandage(Utility.RandomMinMax(5, 15)));
+      pack.DropItem(new Bandage(Utility.RandomMinMax(5, 15)));
+      pack.DropItem(Loot.RandomGem());
+      pack.DropItem(new ArcaneGem());
+
+      PackItem(pack);
+
+      AddItem(new JukaBow());
+
+      // TODO: Bandage self
+    }
+
+    public JukaLord(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a jukan corpse";
+    public override string DefaultName => "a juka lord";
+
+    public override bool AlwaysMurderer => true;
+    public override bool BardImmune => !Core.AOS;
+    public override bool CanRummageCorpses => true;
+    public override int Meat => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Rich);
+      AddLoot(LootPack.Average);
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      if (!willKill && amount > 5 && from?.Player == true && 5 > Utility.Random(100))
+      {
+        string[] toSay =
+        {
+          "{0}!!  You will have to do better than that!",
+          "{0}!!  Prepare to meet your doom!",
+          "{0}!!  My armies will crush you!",
+          "{0}!!  You will pay for that!"
+        };
+
+        Say(true, string.Format(toSay[Utility.Random(toSay.Length)], from.Name));
+      }
+
+      base.OnDamage(amount, from, willKill);
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x262;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x263;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x1D0;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x28D;
+    }
+
+    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/LBR/Jukas/JukaMage.cs

@@ -0,0 +1,201 @@
+using System;
+using Server.Engines.Plants;
+using Server.Items;
+using Server.Spells;
+
+namespace Server.Mobiles
+{
+  public class JukaMage : BaseCreature
+  {
+    private DateTime m_NextAbilityTime;
+
+    [Constructible]
+    public JukaMage() : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 765;
+
+      SetStr(201, 300);
+      SetDex(71, 90);
+      SetInt(451, 500);
+
+      SetHits(121, 180);
+
+      SetDamage(4, 10);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 20, 30);
+      SetResistance(ResistanceType.Fire, 35, 45);
+      SetResistance(ResistanceType.Cold, 30, 40);
+      SetResistance(ResistanceType.Poison, 10, 20);
+      SetResistance(ResistanceType.Energy, 35, 45);
+
+      SetSkill(SkillName.Anatomy, 80.1, 90.0);
+      SetSkill(SkillName.EvalInt, 80.2, 100.0);
+      SetSkill(SkillName.Magery, 99.1, 100.0);
+      SetSkill(SkillName.Meditation, 80.2, 100.0);
+      SetSkill(SkillName.MagicResist, 140.1, 150.0);
+      SetSkill(SkillName.Tactics, 80.1, 90.0);
+      SetSkill(SkillName.Wrestling, 80.1, 90.0);
+
+      Fame = 15000;
+      Karma = -15000;
+
+      VirtualArmor = 16;
+
+      Container bag = new Bag();
+
+      int count = Utility.RandomMinMax(10, 20);
+
+      for (int i = 0; i < count; ++i)
+      {
+        Item item = Loot.RandomReagent();
+
+        if (item == null)
+          continue;
+
+        if (!bag.TryDropItem(this, item, false))
+          item.Delete();
+      }
+
+      PackItem(bag);
+
+      PackItem(new ArcaneGem());
+
+      if (Core.ML && Utility.RandomDouble() < .33)
+        PackItem(Seed.RandomPeculiarSeed(4));
+
+      m_NextAbilityTime = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(2, 5));
+    }
+
+    public JukaMage(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a jukan corpse";
+    public override string DefaultName => "a juka mage";
+
+    public override bool AlwaysMurderer => true;
+    public override bool CanRummageCorpses => true;
+    public override int Meat => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average, 2);
+      AddLoot(LootPack.MedScrolls, 2);
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x1AC;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x1CD;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x1D0;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x28D;
+    }
+
+    public override void OnThink()
+    {
+      if (DateTime.UtcNow >= m_NextAbilityTime)
+      {
+        JukaLord toBuff = null;
+
+        foreach (Mobile m in GetMobilesInRange(8))
+          if (m is JukaLord lord && IsFriend(lord) && lord.Combatant != null && CanBeBeneficial(lord) &&
+              lord.CanBeginAction<JukaMage>() && InLOS(lord))
+          {
+            toBuff = lord;
+            break;
+          }
+
+        if (toBuff != null)
+        {
+          if (CanBeBeneficial(toBuff) && toBuff.BeginAction<JukaMage>())
+          {
+            m_NextAbilityTime = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(30, 60));
+
+            toBuff.Say(true, "Give me the power to destroy my enemies!");
+            Say(true, "Fight well my lord!");
+
+            DoBeneficial(toBuff);
+
+            SpellHelper.Turn(this, toBuff);
+
+            int toScale = toBuff.HitsMaxSeed;
+
+            if (toScale > 0)
+            {
+              toBuff.HitsMaxSeed += AOS.Scale(toScale, 75);
+              toBuff.Hits += AOS.Scale(toScale, 75);
+            }
+
+            toScale = toBuff.RawStr;
+
+            if (toScale > 0)
+              toBuff.RawStr += AOS.Scale(toScale, 50);
+
+            toScale = toBuff.RawDex;
+
+            if (toScale > 0)
+            {
+              toBuff.RawDex += AOS.Scale(toScale, 50);
+              toBuff.Stam += AOS.Scale(toScale, 50);
+            }
+
+            toBuff.Hits = toBuff.Hits;
+            toBuff.Stam = toBuff.Stam;
+
+            toBuff.FixedParticles(0x375A, 10, 15, 5017, EffectLayer.Waist);
+            toBuff.PlaySound(0x1EE);
+
+            Timer.DelayCall(TimeSpan.FromSeconds(20.0), () => Unbuff(toBuff, toBuff.HitsMaxSeed, toBuff.RawStr, toBuff.RawDex));
+          }
+        }
+        else
+        {
+          m_NextAbilityTime = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(2, 5));
+        }
+      }
+
+      base.OnThink();
+    }
+
+    private void Unbuff(JukaLord toDebuff, int hitsMaxSeed, int rawStr, int rawDex)
+    {
+      toDebuff.EndAction<JukaMage>();
+
+      if (toDebuff.Deleted)
+        return;
+
+      toDebuff.HitsMaxSeed = hitsMaxSeed;
+      toDebuff.RawStr = rawStr;
+      toDebuff.RawDex = rawDex;
+
+      toDebuff.Hits = toDebuff.Hits;
+      toDebuff.Stam = toDebuff.Stam;
+    }
+
+    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/LBR/Jukas/JukaWarrior.cs

@@ -0,0 +1,126 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class JukaWarrior : BaseCreature
+  {
+    [Constructible]
+    public JukaWarrior() : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      Body = 764;
+
+      SetStr(251, 350);
+      SetDex(61, 80);
+      SetInt(101, 150);
+
+      SetHits(151, 210);
+
+      SetDamage(7, 9);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 40, 50);
+      SetResistance(ResistanceType.Fire, 30, 40);
+      SetResistance(ResistanceType.Cold, 25, 35);
+      SetResistance(ResistanceType.Poison, 10, 20);
+      SetResistance(ResistanceType.Energy, 10, 20);
+
+      SetSkill(SkillName.Anatomy, 80.1, 90.0);
+      SetSkill(SkillName.Fencing, 80.1, 90.0);
+      SetSkill(SkillName.Macing, 80.1, 90.0);
+      SetSkill(SkillName.MagicResist, 120.1, 130.0);
+      SetSkill(SkillName.Swords, 80.1, 90.0);
+      SetSkill(SkillName.Tactics, 80.1, 90.0);
+      SetSkill(SkillName.Wrestling, 80.1, 90.0);
+
+      Fame = 10000;
+      Karma = -10000;
+
+      VirtualArmor = 22;
+
+      if (Utility.RandomDouble() < 0.1)
+        PackItem(new ArcaneGem());
+    }
+
+    public JukaWarrior(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a jukan corpse";
+    public override string DefaultName => "a juka warrior";
+
+    public override bool AlwaysMurderer => true;
+    public override bool CanRummageCorpses => true;
+    public override int Meat => 1;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Average);
+      AddLoot(LootPack.Meager);
+      AddLoot(LootPack.Gems, 1);
+    }
+
+    public override int GetIdleSound()
+    {
+      return 0x1AC;
+    }
+
+    public override int GetAngerSound()
+    {
+      return 0x1CD;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x1D0;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x28D;
+    }
+
+    public override void OnGaveMeleeAttack(Mobile defender)
+    {
+      base.OnGaveMeleeAttack(defender);
+
+      if (0.2 < Utility.RandomDouble())
+        return;
+
+      switch (Utility.Random(3))
+      {
+        case 0:
+        {
+          defender.SendLocalizedMessage(1004014); // You have been stunned!
+          defender.Freeze(TimeSpan.FromSeconds(4.0));
+          break;
+        }
+        case 1:
+        {
+          defender.SendAsciiMessage("You have been hit by a paralyzing blow!");
+          defender.Freeze(TimeSpan.FromSeconds(3.0));
+          break;
+        }
+        case 2:
+        {
+          AOS.Damage(defender, this, Utility.Random(10, 5), 100, 0, 0, 0, 0);
+          defender.SendAsciiMessage("You have been hit by a critical strike!");
+          break;
+        }
+      }
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/LBR/Meers/EnragedCreatures.cs

@@ -0,0 +1,282 @@
+using Server.Network;
+
+namespace Server.Mobiles
+{
+  public class EnragedRabbit : BaseEnraged
+  {
+    public EnragedRabbit(Mobile summoner) : base(summoner)
+    {
+      Body = 0xcd;
+    }
+
+    public EnragedRabbit(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a hare corpse";
+    public override string DefaultName => "a rabbit";
+
+    public override int GetAttackSound()
+    {
+      return 0xC9;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0xCA;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0xCB;
+    }
+
+    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();
+    }
+  }
+
+  public class EnragedHart : BaseEnraged
+  {
+    public EnragedHart(Mobile summoner) : base(summoner)
+    {
+      Body = 0xea;
+    }
+
+    public EnragedHart(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a deer corpse";
+    public override string DefaultName => "a great hart";
+
+    public override int GetAttackSound()
+    {
+      return 0x82;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x83;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x84;
+    }
+
+    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();
+    }
+  }
+
+  public class EnragedHind : BaseEnraged
+  {
+    public EnragedHind(Mobile summoner) : base(summoner)
+    {
+      Body = 0xed;
+    }
+
+    public EnragedHind(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a deer corpse";
+    public override string DefaultName => "a hind";
+
+    public override int GetAttackSound()
+    {
+      return 0x82;
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x83;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x84;
+    }
+
+    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();
+    }
+  }
+
+  public class EnragedBlackBear : BaseEnraged
+  {
+    public EnragedBlackBear(Mobile summoner) : base(summoner)
+    {
+      Body = 0xd3;
+      BaseSoundID = 0xa3;
+    }
+
+    public EnragedBlackBear(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a bear corpse";
+    public override string DefaultName => "a black bear";
+
+    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();
+    }
+  }
+
+  public class EnragedEagle : BaseEnraged
+  {
+    public EnragedEagle(Mobile summoner) : base(summoner)
+    {
+      Body = 0x5;
+      BaseSoundID = 0x2ee;
+    }
+
+    public EnragedEagle(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "an eagle corpse";
+    public override string DefaultName => "an eagle";
+
+    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();
+    }
+  }
+
+  public class BaseEnraged : BaseCreature
+  {
+    public BaseEnraged(Mobile summoner)
+      : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+    {
+      SetStr(50, 200);
+      SetDex(50, 200);
+      SetHits(50, 200);
+      SetStam(50, 200);
+
+      /*
+        On OSI, all stats are random 50-200, but
+        str is never less than hits, and dex is never
+        less than stam.
+      */
+
+      if (Str < Hits)
+        Str = Hits;
+      if (Dex < Stam)
+        Dex = Stam;
+
+      Karma = -1000;
+      Tamable = false;
+
+      SummonMaster = summoner;
+    }
+
+    public BaseEnraged(Serial serial) : base(serial)
+    {
+    }
+
+    public override void OnThink()
+    {
+      if (SummonMaster?.Deleted != false)
+      {
+        Delete();
+      }
+      /*
+        On OSI, without combatant, they behave as if they have been
+        given "come" command, ie they wander towards their summoner,
+        but never actually "follow".
+      */
+
+      else if (!Combat(this))
+      {
+        AIObject?.MoveTo(SummonMaster, false, 5);
+      }
+      /*
+        On OSI, if the summon attacks a mobile, the summoner meer also
+        attacks them, regardless of karma, etc. as long as the combatant
+        is a player or controlled/summoned, and the summoner is not already
+        engaged in combat.
+      */
+
+      else if (!Combat(SummonMaster))
+      {
+        if (Combatant.Player || Combatant is BaseCreature bc && (bc.Controlled || bc.SummonMaster != null))
+          SummonMaster.Combatant = Combatant;
+      }
+      else
+      {
+        base.OnThink();
+      }
+    }
+
+    private bool Combat(Mobile mobile)
+    {
+      Mobile combatant = mobile.Combatant;
+      return combatant?.Deleted == false && !combatant.IsDeadBondedPet && combatant.Alive;
+    }
+
+    public override void OnSingleClick(Mobile from)
+    {
+      base.OnSingleClick(from);
+      PrivateOverheadMessage(MessageType.Regular, 0x3B2, 1060768, from.NetState); // enraged
+    }
+
+    public override void AddNameProperties(ObjectPropertyList list)
+    {
+      base.AddNameProperties(list);
+      list.Add(1060768); // enraged
+    }
+
+    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/LBR/Meers/MeerCaptain.cs

@@ -0,0 +1,176 @@
+using System;
+using Server.Items;
+using Server.Spells;
+
+namespace Server.Mobiles
+{
+  public class MeerCaptain : BaseCreature
+  {
+    private DateTime m_NextAbilityTime;
+
+    [Constructible]
+    public MeerCaptain() : base(AIType.AI_Archer, FightMode.Evil, 10, 1, 0.2, 0.4)
+    {
+      Body = 773;
+
+      SetStr(96, 110);
+      SetDex(186, 200);
+      SetInt(96, 110);
+
+      SetHits(58, 66);
+
+      SetDamage(5, 15);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 10, 20);
+      SetResistance(ResistanceType.Cold, 40, 50);
+      SetResistance(ResistanceType.Poison, 35, 45);
+      SetResistance(ResistanceType.Energy, 35, 45);
+
+      SetSkill(SkillName.Archery, 90.1, 100.0);
+      SetSkill(SkillName.MagicResist, 91.0, 100.0);
+      SetSkill(SkillName.Swords, 90.1, 100.0);
+      SetSkill(SkillName.Tactics, 91.0, 100.0);
+      SetSkill(SkillName.Wrestling, 80.9, 89.9);
+
+      Fame = 2000;
+      Karma = 5000;
+
+      VirtualArmor = 28;
+
+      Container pack = new Backpack();
+
+      pack.DropItem(new Bolt(Utility.RandomMinMax(10, 20)));
+      pack.DropItem(new Bolt(Utility.RandomMinMax(10, 20)));
+
+      switch (Utility.Random(6))
+      {
+        case 0:
+          pack.DropItem(new Broadsword());
+          break;
+        case 1:
+          pack.DropItem(new Cutlass());
+          break;
+        case 2:
+          pack.DropItem(new Katana());
+          break;
+        case 3:
+          pack.DropItem(new Longsword());
+          break;
+        case 4:
+          pack.DropItem(new Scimitar());
+          break;
+        case 5:
+          pack.DropItem(new VikingSword());
+          break;
+      }
+
+      Container bag = new Bag();
+
+      int count = Utility.RandomMinMax(10, 20);
+
+      for (int i = 0; i < count; ++i)
+      {
+        Item item = Loot.RandomReagent();
+
+        if (item == null)
+          continue;
+
+        if (!bag.TryDropItem(this, item, false))
+          item.Delete();
+      }
+
+      pack.DropItem(bag);
+
+      AddItem(new Crossbow());
+      PackItem(pack);
+
+      m_NextAbilityTime = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(2, 5));
+    }
+
+    public MeerCaptain(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a meer corpse";
+    public override string DefaultName => "a meer captain";
+
+    public override bool BardImmune => !Core.AOS;
+    public override bool CanRummageCorpses => true;
+
+    public override bool InitialInnocent => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x14D;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x314;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x75;
+    }
+
+    public override void OnThink()
+    {
+      if (Combatant != null && MagicDamageAbsorb < 1)
+      {
+        MagicDamageAbsorb = Utility.RandomMinMax(5, 7);
+        FixedParticles(0x375A, 10, 15, 5037, EffectLayer.Waist);
+        PlaySound(0x1E9);
+      }
+
+      if (DateTime.UtcNow >= m_NextAbilityTime)
+      {
+        m_NextAbilityTime = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(10, 15));
+
+        IPooledEnumerable<Mobile> eable = GetMobilesInRange(8);
+
+        foreach (Mobile m in eable)
+        {
+          if (!(m is MeerWarrior) || !IsFriend(m) || !CanBeBeneficial(m) || m.Hits >= m.HitsMax || m.Poisoned ||
+              MortalStrike.IsWounded(m))
+            continue;
+          
+          DoBeneficial(m);
+
+          int toHeal = Utility.RandomMinMax(20, 30);
+
+          SpellHelper.Turn(this, m);
+
+          m.Heal(toHeal, this);
+
+          m.FixedParticles(0x376A, 9, 32, 5030, EffectLayer.Waist);
+          m.PlaySound(0x202);
+        }
+        
+        eable.Free();
+      }
+
+      base.OnThink();
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/LBR/Meers/MeerEternal.cs

@@ -0,0 +1,211 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Server.Mobiles
+{
+  public class MeerEternal : BaseCreature
+  {
+    private DateTime m_NextAbilityTime;
+
+    [Constructible]
+    public MeerEternal() : base(AIType.AI_Mage, FightMode.Evil, 10, 1, 0.2, 0.4)
+    {
+      Body = 772;
+
+      SetStr(416, 505);
+      SetDex(146, 165);
+      SetInt(566, 655);
+
+      SetHits(250, 303);
+
+      SetDamage(11, 13);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 15, 25);
+      SetResistance(ResistanceType.Cold, 45, 55);
+      SetResistance(ResistanceType.Poison, 30, 40);
+      SetResistance(ResistanceType.Energy, 30, 40);
+
+      SetSkill(SkillName.EvalInt, 90.1, 100.0);
+      SetSkill(SkillName.Magery, 90.1, 100.0);
+      SetSkill(SkillName.Meditation, 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 = 34;
+
+      m_NextAbilityTime = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(2, 5));
+    }
+
+    public MeerEternal(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a meer's corpse";
+    public override string DefaultName => "a meer eternal";
+
+    public override bool AutoDispel => true;
+    public override bool BardImmune => !Core.AOS;
+    public override bool CanRummageCorpses => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override int TreasureMapLevel => Core.AOS ? 5 : 4;
+
+    public override bool InitialInnocent => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich, 2);
+      AddLoot(LootPack.MedScrolls, 2);
+      AddLoot(LootPack.HighScrolls, 2);
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x167;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0xBC;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x28B;
+    }
+
+    private void DoAreaLeech()
+    {
+      m_NextAbilityTime += TimeSpan.FromSeconds(2.5);
+
+      Say(true, "Beware, mortals!  You have provoked my wrath!");
+      FixedParticles(0x376A, 10, 10, 9537, 33, 0, EffectLayer.Waist);
+
+      Timer.DelayCall(TimeSpan.FromSeconds(5.0), DoAreaLeech_Finish);
+    }
+
+    private void DoAreaLeech_Finish()
+    {
+      IPooledEnumerable<Mobile> eable = GetMobilesInRange(6);
+      List<Mobile> list = eable.Where(m => CanBeHarmful(m) && IsEnemy(m)).ToList();
+      eable.Free();
+
+      if (list.Count == 0)
+      {
+        Say(true, "Bah! You have escaped my grasp this time, mortal!");
+      }
+      else
+      {
+        double scalar;
+
+        if (list.Count == 1)
+          scalar = 0.75;
+        else if (list.Count == 2)
+          scalar = 0.50;
+        else
+          scalar = 0.25;
+
+        for (int i = 0; i < list.Count; ++i)
+        {
+          Mobile m = list[i];
+
+          int damage = (int)(m.Hits * scalar) + Utility.RandomMinMax(-5, 5);
+
+          m.MovingParticles(this, 0x36F4, 1, 0, false, false, 32, 0, 9535, 1, 0, (EffectLayer)255, 0x100);
+          m.MovingParticles(this, 0x0001, 1, 0, false, true, 32, 0, 9535, 9536, 0, (EffectLayer)255, 0);
+
+          DoHarmful(m);
+          Hits += AOS.Damage(m, this, Math.Max(damage, 1), 100, 0, 0, 0, 0);
+        }
+
+        Say(true, "If I cannot cleanse thy soul, I will destroy it!");
+      }
+    }
+
+    private void DoFocusedLeech(Mobile combatant, string message)
+    {
+      Say(true, message);
+
+      Timer.DelayCall(TimeSpan.FromSeconds(0.5), DoFocusedLeech_Stage1, combatant);
+    }
+
+    private void DoFocusedLeech_Stage1(Mobile combatant)
+    {
+      if (CanBeHarmful(combatant))
+      {
+        MovingParticles(combatant, 0x36FA, 1, 0, false, false, 1108, 0, 9533, 1, 0, (EffectLayer)255, 0x100);
+        MovingParticles(combatant, 0x0001, 1, 0, false, true, 1108, 0, 9533, 9534, 0, (EffectLayer)255, 0);
+        PlaySound(0x1FB);
+
+        Timer.DelayCall(TimeSpan.FromSeconds(1.0), DoFocusedLeech_Stage2, combatant);
+      }
+    }
+
+    private void DoFocusedLeech_Stage2(Mobile combatant)
+    {
+      if (CanBeHarmful(combatant))
+      {
+        combatant.MovingParticles(this, 0x36F4, 1, 0, false, false, 32, 0, 9535, 1, 0, (EffectLayer)255, 0x100);
+        combatant.MovingParticles(this, 0x0001, 1, 0, false, true, 32, 0, 9535, 9536, 0, (EffectLayer)255, 0);
+
+        PlaySound(0x209);
+        DoHarmful(combatant);
+        Hits += AOS.Damage(combatant, this, Utility.RandomMinMax(30, 40) - (Core.AOS ? 0 : 10), 100, 0, 0, 0, 0);
+      }
+    }
+
+    public override void OnThink()
+    {
+      if (DateTime.UtcNow >= m_NextAbilityTime)
+      {
+        Mobile combatant = Combatant;
+
+        if (combatant != null && combatant.Map == Map && combatant.InRange(this, 12))
+        {
+          m_NextAbilityTime = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(10, 15));
+
+          int ability = Utility.Random(4);
+
+          switch (ability)
+          {
+            case 0:
+              DoFocusedLeech(combatant, "Thine essence will fill my withering body with strength!");
+              break;
+            case 1:
+              DoFocusedLeech(combatant,
+                "I rebuke thee, worm, and cleanse thy vile spirit of its tainted blood!");
+              break;
+            case 2:
+              DoFocusedLeech(combatant, "I devour your life's essence to strengthen my resolve!");
+              break;
+            case 3:
+              DoAreaLeech();
+              break;
+            // TODO: Resurrect ability
+          }
+        }
+      }
+
+      base.OnThink();
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/LBR/Meers/MeerMage.cs

@@ -0,0 +1,220 @@
+using System;
+using System.Collections.Generic;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Mobiles
+{
+  public class MeerMage : BaseCreature
+  {
+    private static Dictionary<Mobile, Timer> m_Table = new Dictionary<Mobile, Timer>();
+
+    private DateTime m_NextAbilityTime;
+
+    [Constructible]
+    public MeerMage() : base(AIType.AI_Mage, FightMode.Evil, 10, 1, 0.2, 0.4)
+    {
+      Body = 770;
+
+      SetStr(171, 200);
+      SetDex(126, 145);
+      SetInt(276, 305);
+
+      SetHits(103, 120);
+
+      SetDamage(24, 26);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 45, 55);
+      SetResistance(ResistanceType.Fire, 15, 25);
+      SetResistance(ResistanceType.Cold, 50);
+      SetResistance(ResistanceType.Poison, 25, 35);
+      SetResistance(ResistanceType.Energy, 25, 35);
+
+      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);
+      SetSkill(SkillName.Wrestling, 60.1, 80.0);
+
+      Fame = 8000;
+      Karma = 8000;
+
+      VirtualArmor = 16;
+
+      m_NextAbilityTime = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(2, 5));
+    }
+
+    public MeerMage(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a meer's corpse";
+    public override string DefaultName => "a meer mage";
+
+    public override bool AutoDispel => true;
+    public override Poison PoisonImmune => Poison.Lethal;
+    public override bool CanRummageCorpses => true;
+    public override int TreasureMapLevel => 3;
+
+    public override bool InitialInnocent => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.FilthyRich);
+      AddLoot(LootPack.MedScrolls, 2);
+      // TODO: Daemon bone ...
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x14D;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x314;
+    }
+
+    public override int GetAttackSound()
+    {
+      return 0x75;
+    }
+
+    public override void OnThink()
+    {
+      if (DateTime.UtcNow >= m_NextAbilityTime)
+      {
+        Mobile combatant = Combatant;
+
+        if (combatant != null && combatant.Map == Map && combatant.InRange(this, 12) && IsEnemy(combatant) &&
+            !UnderEffect(combatant))
+        {
+          m_NextAbilityTime = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(20, 30));
+
+          if (combatant is BaseCreature bc)
+            if (bc.Controlled && bc.ControlMaster?.Deleted == false && bc.ControlMaster.Alive)
+              if (bc.ControlMaster.Map == Map && bc.ControlMaster.InRange(this, 12) &&
+                  !UnderEffect(bc.ControlMaster))
+                Combatant = combatant = bc.ControlMaster;
+
+          if (Utility.RandomDouble() < .1)
+          {
+            int[][] coord =
+            {
+              new[] { -4, -6 }, new[] { 4, -6 }, new[] { 0, -8 }, new[] { -5, 5 }, new[] { 5, 5 }
+            };
+
+            for (int i = 0; i < 5; i++)
+            {
+              int x = combatant.X + coord[i][0];
+              int y = combatant.Y + coord[i][1];
+
+              Point3D loc = new Point3D(x, y, combatant.Map.GetAverageZ(x, y));
+
+              if (!combatant.Map.CanSpawnMobile(loc))
+                continue;
+
+              BaseCreature rabid;
+              switch (i)
+              {
+                case 0:
+                  rabid = new EnragedRabbit(this);
+                  break;
+                case 1:
+                  rabid = new EnragedHind(this);
+                  break;
+                case 2:
+                  rabid = new EnragedHart(this);
+                  break;
+                case 3:
+                  rabid = new EnragedBlackBear(this);
+                  break;
+                default:
+                  rabid = new EnragedEagle(this);
+                  break;
+              }
+
+              rabid.FocusMob = combatant;
+              rabid.MoveToWorld(loc, combatant.Map);
+            }
+
+            Say(1071932); //Creatures of the forest, I call to thee!  Aid me in the fight against all that is evil!
+          }
+          else if (combatant.Player)
+          {
+            int count = 0;
+
+            Say(true, "I call a plague of insects to sting your flesh!");
+            m_Table[combatant] = Timer.DelayCall(TimeSpan.FromSeconds(0.5), TimeSpan.FromSeconds(7.0),
+              () => DoEffect(combatant, count++));
+          }
+        }
+      }
+
+      base.OnThink();
+    }
+
+    public static bool UnderEffect(Mobile m)
+    {
+      return m_Table.ContainsKey(m);
+    }
+
+    public static void StopEffect(Mobile m, bool message)
+    {
+      if (m_Table.TryGetValue(m, out Timer timer))
+      {
+        if (message)
+          m.PublicOverheadMessage(MessageType.Emote, m.SpeechHue, true,
+            "* The open flame begins to scatter the swarm of insects *");
+
+        timer.Stop();
+        m_Table.Remove(m);
+      }
+    }
+
+    public void DoEffect(Mobile m, int count)
+    {
+      if (!m.Alive)
+        StopEffect(m, false);
+      else
+      {
+        if (m.FindItemOnLayer(Layer.TwoHanded) is Torch torch && torch.Burning)
+          StopEffect(m, true);
+        else
+        {
+          if (count % 4 == 0)
+          {
+            m.LocalOverheadMessage(MessageType.Emote, m.SpeechHue, true,
+              "* The swarm of insects bites and stings your flesh! *");
+            m.NonlocalOverheadMessage(MessageType.Emote, m.SpeechHue, true,
+              $"* {m.Name} is stung by a swarm of insects *");
+          }
+
+          m.FixedParticles(0x91C, 10, 180, 9539, EffectLayer.Waist);
+          m.PlaySound(0x00E);
+          m.PlaySound(0x1BC);
+
+          AOS.Damage(m, this, Utility.RandomMinMax(30, 40) - (Core.AOS ? 0 : 10), 100, 0, 0, 0, 0);
+
+          if (!m.Alive)
+            StopEffect(m, false);
+        }
+      }
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Mobiles/Monsters/LBR/Meers/MeerWarrior.cs

@@ -0,0 +1,90 @@
+using System;
+using Server.Spells;
+
+namespace Server.Mobiles
+{
+  public class MeerWarrior : BaseCreature
+  {
+    [Constructible]
+    public MeerWarrior() : base(AIType.AI_Melee, FightMode.Evil, 10, 1, 0.2, 0.4)
+    {
+      Body = 771;
+
+      SetStr(86, 100);
+      SetDex(186, 200);
+      SetInt(86, 100);
+
+      SetHits(52, 60);
+
+      SetDamage(12, 19);
+
+      SetDamageType(ResistanceType.Physical, 100);
+
+      SetResistance(ResistanceType.Physical, 35, 45);
+      SetResistance(ResistanceType.Fire, 5, 15);
+      SetResistance(ResistanceType.Cold, 30, 40);
+      SetResistance(ResistanceType.Poison, 25, 35);
+      SetResistance(ResistanceType.Energy, 25, 35);
+
+      SetSkill(SkillName.MagicResist, 91.0, 100.0);
+      SetSkill(SkillName.Tactics, 91.0, 100.0);
+      SetSkill(SkillName.Wrestling, 91.0, 100.0);
+
+      VirtualArmor = 22;
+
+      Fame = 2000;
+      Karma = 5000;
+    }
+
+    public MeerWarrior(Serial serial) : base(serial)
+    {
+    }
+
+    public override string CorpseName => "a meer corpse";
+    public override string DefaultName => "a meer warrior";
+
+    public override bool BardImmune => !Core.AOS;
+    public override bool CanRummageCorpses => true;
+
+    public override bool InitialInnocent => true;
+
+    public override void GenerateLoot()
+    {
+      AddLoot(LootPack.Meager);
+    }
+
+    public override void OnDamage(int amount, Mobile from, bool willKill)
+    {
+      if (from != null && !willKill && amount > 3 && !InRange(from, 7))
+      {
+        MovingEffect(from, 0xF51, 10, 0, false, false);
+        SpellHelper.Damage(TimeSpan.FromSeconds(1.0), from, this, Utility.RandomMinMax(30, 40) - (Core.AOS ? 0 : 10),
+          100, 0, 0, 0, 0);
+      }
+
+      base.OnDamage(amount, from, willKill);
+    }
+
+    public override int GetHurtSound()
+    {
+      return 0x156;
+    }
+
+    public override int GetDeathSound()
+    {
+      return 0x15C;
+    }
+
+    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();
+    }
+  }
+}