v0.0.1-Alpha (#42)

Projects/Scripts/Items/Talismans/Items/EnchantedSwitch.cs

@@ -0,0 +1,31 @@
+namespace Server.Items
+{
+  public class EnchantedSwitch : Item
+  {
+    [Constructible]
+    public EnchantedSwitch() : base(0x2F5C)
+    {
+      Weight = 1.0;
+    }
+
+    public EnchantedSwitch(Serial serial) : base(serial)
+    {
+    }
+
+    public override int LabelNumber => 1072893; // enchanted switch
+
+    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/Items/Talismans/Items/HollowPrism.cs

@@ -0,0 +1,31 @@
+namespace Server.Items
+{
+  public class HollowPrism : Item
+  {
+    [Constructible]
+    public HollowPrism() : base(0x2F5D)
+    {
+      Weight = 1.0;
+    }
+
+    public HollowPrism(Serial serial) : base(serial)
+    {
+    }
+
+    public override int LabelNumber => 1072895; // hollow prism
+
+    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/Items/Talismans/Items/JeweledFiligree.cs

@@ -0,0 +1,31 @@
+namespace Server.Items
+{
+  public class JeweledFiligree : Item
+  {
+    [Constructible]
+    public JeweledFiligree() : base(0x2F5E)
+    {
+      Weight = 1.0;
+    }
+
+    public JeweledFiligree(Serial serial) : base(serial)
+    {
+    }
+
+    public override int LabelNumber => 1072894; // jeweled filigree
+
+    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/Items/Talismans/Items/RunedPrism.cs

@@ -0,0 +1,31 @@
+namespace Server.Items
+{
+  public class RunedPrism : Item
+  {
+    [Constructible]
+    public RunedPrism() : base(0x2F57)
+    {
+      Weight = 1.0;
+    }
+
+    public RunedPrism(Serial serial) : base(serial)
+    {
+    }
+
+    public override int LabelNumber => 1073465; // runed prism
+
+    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/Items/Talismans/Items/RunedSwitch.cs

@@ -0,0 +1,81 @@
+using Server.Targeting;
+
+namespace Server.Items
+{
+  public class RunedSwitch : Item
+  {
+    [Constructible]
+    public RunedSwitch() : base(0x2F61)
+    {
+      Weight = 1.0;
+    }
+
+    public RunedSwitch(Serial serial) : base(serial)
+    {
+    }
+
+    public override int LabelNumber => 1072896; // runed switch
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      if (IsChildOf(from.Backpack))
+      {
+        from.SendLocalizedMessage(1075101); // Please select an item to recharge.
+        from.Target = new InternalTarget(this);
+      }
+      else
+      {
+        from.SendLocalizedMessage(1060640); // The item must be in your backpack to use it.
+      }
+    }
+
+    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();
+    }
+
+    private class InternalTarget : Target
+    {
+      private RunedSwitch m_Item;
+
+      public InternalTarget(RunedSwitch item) : base(0, false, TargetFlags.None)
+      {
+        m_Item = item;
+      }
+
+      protected override void OnTarget(Mobile from, object o)
+      {
+        if (m_Item?.Deleted != false)
+          return;
+
+        if (o is BaseTalisman talisman)
+        {
+          if (talisman.Charges == 0)
+          {
+            talisman.Charges = talisman.MaxCharges;
+            m_Item.Delete();
+            from.SendLocalizedMessage(1075100); // The item has been recharged.
+          }
+          else
+          {
+            from.SendLocalizedMessage(
+              1075099); // You cannot recharge that item until all of its current charges have been used.
+          }
+        }
+        else
+        {
+          from.SendLocalizedMessage(1046439); // That is not a valid target.
+        }
+      }
+    }
+  }
+}

Projects/Scripts/Items/Talismans/RandomTalisman.cs

@@ -0,0 +1,58 @@
+namespace Server.Items
+{
+  public class RandomTalisman : BaseTalisman
+  {
+    [Constructible]
+    public RandomTalisman() : base(GetRandomItemID())
+    {
+      Summoner = GetRandomSummoner();
+
+      if (Summoner.IsEmpty)
+      {
+        Removal = GetRandomRemoval();
+
+        if (Removal != TalismanRemoval.None)
+        {
+          MaxCharges = GetRandomCharges();
+          MaxChargeTime = 1200;
+        }
+      }
+      else
+      {
+        MaxCharges = Utility.RandomMinMax(10, 50);
+
+        if (Summoner.IsItem)
+          MaxChargeTime = 60;
+        else
+          MaxChargeTime = 1800;
+      }
+
+      Blessed = GetRandomBlessed();
+      Slayer = GetRandomSlayer();
+      Protection = GetRandomProtection();
+      Killer = GetRandomKiller();
+      Skill = GetRandomSkill();
+      ExceptionalBonus = GetRandomExceptional();
+      SuccessBonus = GetRandomSuccessful();
+      Charges = MaxCharges;
+    }
+
+    public RandomTalisman(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/Items/Talismans/TalismanAttribute.cs

@@ -0,0 +1,112 @@
+using System;
+
+namespace Server.Items
+{
+  [PropertyObject]
+  public class TalismanAttribute
+  {
+    public TalismanAttribute() : this(null, 0)
+    {
+    }
+
+    public TalismanAttribute(TalismanAttribute copy)
+    {
+      if (copy != null)
+      {
+        Type = copy.Type;
+        Name = copy.Name;
+        Amount = copy.Amount;
+      }
+    }
+
+    public TalismanAttribute(Type type, TextDefinition name, int amount = 0)
+    {
+      Type = type;
+      Name = name;
+      Amount = amount;
+    }
+
+    public TalismanAttribute(GenericReader reader)
+    {
+      int version = reader.ReadInt();
+
+      SaveFlag flags = (SaveFlag)reader.ReadEncodedInt();
+
+      if (GetSaveFlag(flags, SaveFlag.Type))
+        Type = ScriptCompiler.FindTypeByFullName(reader.ReadString(), false);
+
+      if (GetSaveFlag(flags, SaveFlag.Name))
+        Name = TextDefinition.Deserialize(reader);
+
+      if (GetSaveFlag(flags, SaveFlag.Amount))
+        Amount = reader.ReadEncodedInt();
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public Type Type{ get; set; }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public TextDefinition Name{ get; set; }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public int Amount{ get; set; }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public bool IsEmpty => Type == null;
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public bool IsItem => Type?.Namespace.Equals("Server.Items") == true;
+
+    public override string ToString()
+    {
+      return Type?.Name ?? "None";
+    }
+
+    private static void SetSaveFlag(ref SaveFlag flags, SaveFlag toSet, bool setIf)
+    {
+      if (setIf)
+        flags |= toSet;
+    }
+
+    private static bool GetSaveFlag(SaveFlag flags, SaveFlag toGet)
+    {
+      return (flags & toGet) != 0;
+    }
+
+    public virtual void Serialize(GenericWriter writer)
+    {
+      writer.Write(0); // version
+
+      SaveFlag flags = SaveFlag.None;
+
+      SetSaveFlag(ref flags, SaveFlag.Type, Type != null);
+      SetSaveFlag(ref flags, SaveFlag.Name, Name != null);
+      SetSaveFlag(ref flags, SaveFlag.Amount, Amount != 0);
+
+      writer.WriteEncodedInt((int)flags);
+
+      if (GetSaveFlag(flags, SaveFlag.Type))
+        writer.Write(Type.FullName);
+
+      if (GetSaveFlag(flags, SaveFlag.Name))
+        TextDefinition.Serialize(writer, Name);
+
+      if (GetSaveFlag(flags, SaveFlag.Amount))
+        writer.WriteEncodedInt(Amount);
+    }
+
+    public int DamageBonus(Mobile to)
+    {
+      return to?.GetType() == Type ? Amount : 0;
+    }
+
+    [Flags]
+    private enum SaveFlag
+    {
+      None = 0x00000000,
+      Type = 0x00000001,
+      Name = 0x00000002,
+      Amount = 0x00000004
+    }
+  }
+}

Projects/Scripts/Items/Talismans/TalismanSlayer.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+  public enum TalismanSlayerName
+  {
+    None,
+    Bear,
+    Vermin,
+    Bat,
+    Mage,
+    Beetle,
+    Bird,
+    Ice,
+    Flame,
+    Bovine
+  }
+
+  public static class TalismanSlayer
+  {
+    private static Dictionary<TalismanSlayerName, Type[]> m_Table;
+
+    public static void Initialize()
+    {
+      m_Table = new Dictionary<TalismanSlayerName, Type[]>
+      {
+        [TalismanSlayerName.Bear] = new[]
+        {
+          typeof(GrizzlyBear), typeof(BlackBear), typeof(BrownBear), typeof(PolarBear) //, typeof( Grobu )
+        },
+        [TalismanSlayerName.Vermin] = new[]
+        {
+          typeof(RatmanMage), typeof(RatmanMage), typeof(RatmanArcher), typeof(Barracoon), typeof(Ratman), typeof(SewerRat),
+          typeof(Rat), typeof(GiantRat) //, typeof( Chiikkaha )
+        },
+        [TalismanSlayerName.Bat] = new[] { typeof(Mongbat), typeof(StrongMongbat), typeof(VampireBat) },
+        [TalismanSlayerName.Mage] =
+          new[]
+          {
+            typeof(EvilMage), typeof(EvilMageLord), typeof(AncientLich), typeof(Lich), typeof(LichLord),
+            typeof(SkeletalMage), typeof(BoneMagi), typeof(OrcishMage), typeof(KhaldunZealot), typeof(JukaMage)
+          },
+        [TalismanSlayerName.Beetle] =
+          new[]
+          {
+            typeof(Beetle), typeof(RuneBeetle), typeof(FireBeetle), typeof(DeathwatchBeetle),
+            typeof(DeathwatchBeetleHatchling)
+          },
+        [TalismanSlayerName.Bird] = new[]
+        {
+          typeof(Bird), typeof(TropicalBird), typeof(Chicken), typeof(Crane), typeof(DesertOstard), typeof(Eagle),
+          typeof(ForestOstard), typeof(FrenziedOstard),
+          typeof(Phoenix), /*typeof( Pyre ), typeof( Swoop ), typeof( Saliva ),*/ typeof(Harpy), typeof(StoneHarpy) // ?????
+        },
+        [TalismanSlayerName.Ice] = new[]
+        {
+          typeof(ArcticOgreLord), typeof(IceElemental), typeof(SnowElemental), typeof(FrostOoze),
+          typeof(IceFiend), /*typeof( UnfrozenMummy ),*/ typeof(FrostSpider), typeof(LadyOfTheSnow), typeof(FrostTroll),
+
+          // TODO WinterReaper, check
+          typeof(IceSnake), typeof(SnowLeopard), typeof(PolarBear), typeof(IceSerpent), typeof(GiantIceWorm)
+        },
+        [TalismanSlayerName.Flame] = new[]
+        {
+          typeof(FireBeetle), typeof(HellHound), typeof(LavaSerpent), typeof(FireElemental), typeof(PredatorHellCat),
+          typeof(Phoenix), typeof(FireGargoyle), typeof(HellCat),
+          /*typeof( Pyre ),*/ typeof(FireSteed), typeof(LavaLizard),
+
+          // TODO check
+          typeof(LavaSnake)
+        },
+        [TalismanSlayerName.Bovine] = new[]
+        {
+          typeof(Cow), typeof(Bull), typeof(Gaman) /*, typeof( MinotaurCaptain ),
+				  typeof( MinotaurScout ), typeof( Minotaur )*/
+          // TODO TormentedMinotaur
+        }
+      };
+    }
+
+    public static bool Slays(TalismanSlayerName name, Mobile m)
+    {
+      if (m == null || !m_Table.TryGetValue(name, out Type[] types) || types == null)
+        return false;;
+
+      Type type = m.GetType();
+
+      for (int i = 0; i < types.Length; i++)
+        if (types[i].IsAssignableFrom(type))
+          return true;
+
+      return false;
+    }
+  }
+}

Projects/Scripts/Items/Talismans/TalismanSummons.cs

@@ -0,0 +1,637 @@
+using System;
+using System.Collections.Generic;
+using Server.ContextMenus;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+  public class BaseTalismanSummon : BaseCreature
+  {
+    //public override bool IsInvulnerable => true; // TODO: Wailing banshees are NOT invulnerable, are any of the others?
+
+    public BaseTalismanSummon() : base(AIType.AI_Melee, FightMode.None, 10, 1, 0.2, 0.4)
+    {
+      // TODO: Stats/skills
+    }
+
+    public BaseTalismanSummon(Serial serial) : base(serial)
+    {
+    }
+
+    public override bool Commandable => false;
+    public override bool InitialInnocent => true;
+
+    public override void AddCustomContextEntries(Mobile from, List<ContextMenuEntry> list)
+    {
+      if (from.Alive && ControlMaster == from)
+        list.Add(new TalismanReleaseEntry(this));
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+
+    private class TalismanReleaseEntry : ContextMenuEntry
+    {
+      private Mobile m_Mobile;
+
+      public TalismanReleaseEntry(Mobile m) : base(6118, 3)
+      {
+        m_Mobile = m;
+      }
+
+      public override void OnClick()
+      {
+        Effects.SendLocationParticles(EffectItem.Create(m_Mobile.Location, m_Mobile.Map, EffectItem.DefaultDuration),
+          0x3728, 8, 20, 5042);
+        Effects.PlaySound(m_Mobile, m_Mobile.Map, 0x201);
+
+        m_Mobile.Delete();
+      }
+    }
+  }
+
+  public class SummonedAntLion : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedAntLion()
+    {
+      Body = 787;
+      BaseSoundID = 1006;
+    }
+
+    public SummonedAntLion(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "an ant lion";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedArcticOgreLord : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedArcticOgreLord()
+    {
+      Body = 135;
+      BaseSoundID = 427;
+    }
+
+    public SummonedArcticOgreLord(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "an arctic ogre lord";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedBakeKitsune : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedBakeKitsune()
+    {
+      Body = 246;
+      BaseSoundID = 0x4DD;
+    }
+
+    public SummonedBakeKitsune(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a bake kitsune";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedBogling : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedBogling()
+    {
+      Body = 779;
+      BaseSoundID = 422;
+    }
+
+    public SummonedBogling(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a bogling";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedBullFrog : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedBullFrog()
+    {
+      Body = 81;
+      Hue = Utility.RandomList(0x5AC, 0x5A3, 0x59A, 0x591, 0x588, 0x57F);
+      BaseSoundID = 0x266;
+    }
+
+    public SummonedBullFrog(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a bull frog";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedChicken : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedChicken()
+    {
+      Body = 0xD0;
+      BaseSoundID = 0x6E;
+    }
+
+    public SummonedChicken(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a chicken";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedCow : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedCow()
+    {
+      Body = Utility.RandomList(0xD8, 0xE7);
+      BaseSoundID = 0x78;
+    }
+
+    public SummonedCow(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a cow";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedDoppleganger : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedDoppleganger()
+    {
+      Body = 0x309;
+      BaseSoundID = 0x451;
+    }
+
+    public SummonedDoppleganger(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a doppleganger";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedFrostSpider : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedFrostSpider()
+    {
+      Body = 20;
+      BaseSoundID = 0x388;
+    }
+
+    public SummonedFrostSpider(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a frost spider";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedGreatHart : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedGreatHart()
+    {
+      Body = 0xEA;
+      BaseSoundID = 0x82;
+    }
+
+    public SummonedGreatHart(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a great hart";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedLavaSerpent : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedLavaSerpent()
+    {
+      Body = 90;
+      BaseSoundID = 219;
+    }
+
+    public SummonedLavaSerpent(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a lava serpent";
+
+    public override void OnThink()
+    {
+      /*
+      if ( m_NextWave < DateTime.UtcNow )
+        AreaHeatDamage();
+      */
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+
+    /*
+    // An area attack that only damages staff, wtf?
+
+    private DateTime m_NextWave;
+
+    public void AreaHeatDamage()
+    {
+      Mobile mob = ControlMaster;
+
+      if ( mob != null )
+      {
+        if ( mob.InRange( Location, 2 ) )
+        {
+          if ( mob.AccessLevel != AccessLevel.Player )
+          {
+            AOS.Damage( mob, Utility.Random( 2, 3 ), 0, 100, 0, 0, 0 );
+            mob.SendLocalizedMessage( 1008112 ); // The intense heat is damaging you!
+          }
+        }
+
+        GuardedRegion r = Region as GuardedRegion;
+
+        if ( r != null && mob.Alive )
+        {
+          foreach ( Mobile m in GetMobilesInRange( 2 ) )
+          {
+            if ( !mob.CanBeHarmful( m ) )
+              mob.CriminalAction( false );
+          }
+        }
+      }
+
+      m_NextWave = DateTime.UtcNow + TimeSpan.FromSeconds( 3 );
+    }
+    */
+  }
+
+  public class SummonedOrcBrute : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedOrcBrute()
+    {
+      Body = 189;
+      BaseSoundID = 0x45A;
+    }
+
+    public SummonedOrcBrute(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "an orc brute";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedPanther : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedPanther()
+    {
+      Body = 0xD6;
+      Hue = 0x901;
+      BaseSoundID = 0x462;
+    }
+
+    public SummonedPanther(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a panther";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedSheep : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedSheep()
+    {
+      Body = 0xCF;
+      BaseSoundID = 0xD6;
+    }
+
+    public SummonedSheep(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a sheep";
+
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedSkeletalKnight : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedSkeletalKnight()
+    {
+      Body = 147;
+      BaseSoundID = 451;
+    }
+
+    public SummonedSkeletalKnight(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a skeletal knight";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedVorpalBunny : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedVorpalBunny()
+    {
+      Body = 205;
+      Hue = 0x480;
+      BaseSoundID = 0xC9;
+
+      Timer.DelayCall(TimeSpan.FromMinutes(30.0), BeginTunnel);
+    }
+
+    public SummonedVorpalBunny(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a vorpal bunny";
+
+    public virtual void BeginTunnel()
+    {
+      if (Deleted)
+        return;
+
+      new VorpalBunny.BunnyHole().MoveToWorld(Location, Map);
+
+      Frozen = true;
+      Say("* The bunny begins to dig a tunnel back to its underground lair *");
+      PlaySound(0x247);
+
+      Timer.DelayCall(TimeSpan.FromSeconds(5.0), Delete);
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SummonedWailingBanshee : BaseTalismanSummon
+  {
+    [Constructible]
+    public SummonedWailingBanshee()
+    {
+      Body = 310;
+      BaseSoundID = 0x482;
+    }
+
+    public SummonedWailingBanshee(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "a wailing banshee";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+}