#W# Source and Scripts added. Added Scripts/Settings.cs to expose some basic tweak able settings.

Scripts/Items/Talismans/Items/EnchantedSwitch.cs

@@ -0,0 +1,33 @@
+using System;
+
+namespace Server.Items
+{
+	public class EnchantedSwitch : Item
+	{
+		public override int LabelNumber{ get{ return 1072893; } } // enchanted switch
+
+		[Constructable]
+		public EnchantedSwitch() : base( 0x2F5C )
+		{
+			Weight = 1.0;
+		}
+
+		public EnchantedSwitch( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Items/Talismans/Items/HollowPrism.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace Server.Items
+{
+	public class HollowPrism : Item
+	{
+	public override int LabelNumber{ get{ return 1072895; } } // hollow prism
+	
+		[Constructable]
+		public HollowPrism() : base( 0x2F5D )
+		{
+			Weight = 1.0;
+		}
+
+		public HollowPrism( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}
+

Scripts/Items/Talismans/Items/JeweledFiligree.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace Server.Items
+{
+	public class JeweledFiligree : Item
+	{
+		public override int LabelNumber{ get{ return 1072894; } } // jeweled filigree
+
+		[Constructable]
+		public JeweledFiligree() : base( 0x2F5E )
+		{
+			Weight = 1.0;
+		}
+
+		public JeweledFiligree( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}
+

Scripts/Items/Talismans/Items/RunedPrism.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace Server.Items
+{
+	public class RunedPrism : Item
+	{
+		public override int LabelNumber{ get{ return 1073465; } } // runed prism
+
+		[Constructable]
+		public RunedPrism() : base( 0x2F57 )
+		{
+			Weight = 1.0;
+		}
+
+		public RunedPrism( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}
+

Scripts/Items/Talismans/Items/RunedSwitch.cs

@@ -0,0 +1,79 @@
+using System;
+using Server;
+using Server.Targeting;
+
+namespace Server.Items
+{
+	public class RunedSwitch : Item
+	{
+		public override int LabelNumber{ get{ return 1072896; } } // runed switch
+
+		[Constructable]
+		public RunedSwitch() : base( 0x2F61 )
+		{
+			Weight = 1.0;
+		}
+
+		public RunedSwitch( Serial serial ) : base( serial )
+		{
+		}
+
+		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( (int) 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 == null || m_Item.Deleted )
+					return;
+
+				if ( o is BaseTalisman )
+				{
+					BaseTalisman talisman = (BaseTalisman) o;
+
+					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.
+			}
+		}
+	}
+}
+

Scripts/Items/Talismans/RandomTalisman.cs

@@ -0,0 +1,63 @@
+using System;
+using Server;
+using Server.Mobiles;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class RandomTalisman : BaseTalisman
+	{
+		[Constructable]
+		public RandomTalisman() : base( GetRandomItemID() )
+		{
+			Summoner = BaseTalisman.GetRandomSummoner();
+
+			if ( Summoner.IsEmpty )
+			{
+				Removal = BaseTalisman.GetRandomRemoval();
+
+				if ( Removal != TalismanRemoval.None )
+				{
+					MaxCharges = BaseTalisman.GetRandomCharges();
+					MaxChargeTime = 1200;
+				}
+			}
+			else
+			{
+				MaxCharges = Utility.RandomMinMax( 10, 50 );
+
+				if ( Summoner.IsItem )
+					MaxChargeTime = 60;
+				else
+					MaxChargeTime = 1800;
+			}
+
+			Blessed = BaseTalisman.GetRandomBlessed();
+			Slayer = BaseTalisman.GetRandomSlayer();
+			Protection = BaseTalisman.GetRandomProtection();
+			Killer = BaseTalisman.GetRandomKiller();
+			Skill = BaseTalisman.GetRandomSkill();
+			ExceptionalBonus = BaseTalisman.GetRandomExceptional();
+			SuccessBonus = BaseTalisman.GetRandomSuccessful();
+			Charges = MaxCharges;
+		}
+
+		public RandomTalisman( Serial serial ) :  base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Items/Talismans/TalismanAttribute.cs

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

Scripts/Items/Talismans/TalismanSlayer.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using Server;
+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 = new Dictionary<TalismanSlayerName,Type[]>();
+
+		public static void Initialize()
+		{
+			m_Table[ TalismanSlayerName.Bear ] = new Type[]
+			{
+				typeof( GrizzlyBear ), typeof( BlackBear ), typeof( BrownBear ), typeof( PolarBear ) //, typeof( Grobu )
+			};
+
+			m_Table[ TalismanSlayerName.Vermin ] = new Type[]
+			{
+				typeof( RatmanMage ), typeof( RatmanMage ), typeof( RatmanArcher ), typeof( Barracoon),
+				typeof( Ratman ), typeof( Sewerrat ), typeof( Rat ), typeof( GiantRat ) //, typeof( Chiikkaha )
+			};
+
+			m_Table[ TalismanSlayerName.Bat ] = new Type[]
+			{
+				typeof( Mongbat ), typeof( StrongMongbat ), typeof( VampireBat )
+			};
+			
+			m_Table[ TalismanSlayerName.Mage ] = new Type[]
+			{
+				typeof( EvilMage ), typeof( EvilMageLord ), typeof( AncientLich ), typeof( Lich ), typeof( LichLord ),
+				typeof( SkeletalMage ), typeof( BoneMagi ), typeof( OrcishMage ), typeof( KhaldunZealot ), typeof( JukaMage ),
+			};
+
+			m_Table[ TalismanSlayerName.Beetle ] = new Type[]
+			{
+				typeof( Beetle ), typeof( RuneBeetle ), typeof( FireBeetle ), typeof( DeathwatchBeetle ),
+				typeof( DeathwatchBeetleHatchling )
+			};
+
+			m_Table[ TalismanSlayerName.Bird ] = new Type[]
+			{
+				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 ) // ?????
+			};
+
+			m_Table[ TalismanSlayerName.Ice ] = new Type[]
+			{ 
+				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 )
+			};
+			
+			m_Table[ TalismanSlayerName.Flame ] = new Type[]
+			{
+				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 ),
+			};
+
+			m_Table[ TalismanSlayerName.Bovine ] = new Type[]
+			{
+				typeof( Cow ), typeof( Bull ), typeof( Gaman ) /*, typeof( MinotaurCaptain ),
+				typeof( MinotaurScout ), typeof( Minotaur )*/
+
+				// TODO TormentedMinotaur
+			};
+		}
+
+		public static bool Slays( TalismanSlayerName name, Mobile m )
+		{
+			if ( !m_Table.ContainsKey( name ) )
+				return false;
+
+			Type[] types = m_Table[ name ];
+			
+			if ( types == null || m == null )
+				return false;
+
+			Type type = m.GetType();
+
+			for ( int i = 0; i < types.Length; i++ )
+			{
+				if ( types[ i ].IsAssignableFrom( type ) )
+					return true;
+			}
+
+			return false;
+		}
+	}
+}

Scripts/Items/Talismans/TalismanSummons.cs

@@ -0,0 +1,621 @@
+using System;
+using System.Collections.Generic;
+
+using Server.ContextMenus;
+using Server.Regions;
+using Server.Items;
+
+using BunnyHole = Server.Mobiles.VorpalBunny.BunnyHole;
+
+namespace Server.Mobiles
+{
+	public class BaseTalismanSummon : BaseCreature
+	{
+		public override bool Commandable{ get{ return false; } }
+		public override bool InitialInnocent{ get{ return true; } }
+		//public override bool IsInvulnerable{ get{ return 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 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
+	{
+		[Constructable]
+		public SummonedAntLion() : base()
+		{
+			Name = "an ant lion";
+			Body = 787;
+			BaseSoundID = 1006;
+		}
+
+		public SummonedAntLion( Serial serial )	: base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedArcticOgreLord()	: base()
+		{
+			Name = "an arctic ogre lord";
+			Body = 135;
+			BaseSoundID = 427;
+		}
+
+		public SummonedArcticOgreLord( Serial serial ) : base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedBakeKitsune() : base()
+		{
+			Name = "a bake kitsune";
+			Body = 246;
+			BaseSoundID = 0x4DD;
+		}
+
+		public SummonedBakeKitsune( Serial serial ) : base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedBogling() : base()
+		{
+			Name = "a bogling";
+			Body = 779;
+			BaseSoundID = 422;
+		}
+
+		public SummonedBogling( Serial serial )	: base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedBullFrog() : base()
+		{
+			Name = "a bull frog";
+			Body = 81;
+			Hue = Utility.RandomList( 0x5AC, 0x5A3, 0x59A, 0x591, 0x588, 0x57F );
+			BaseSoundID = 0x266;
+		}
+
+		public SummonedBullFrog( Serial serial ) : base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedChicken() : base()
+		{
+			Name = "a chicken";
+			Body = 0xD0;
+			BaseSoundID = 0x6E;
+		}
+
+		public SummonedChicken( Serial serial ) : base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedCow() : base()
+		{
+			Name = "a cow";
+			Body = Utility.RandomList( 0xD8, 0xE7 );
+			BaseSoundID = 0x78;
+		}
+
+		public SummonedCow( Serial serial ) : base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedDoppleganger() : base()
+		{
+			Name = "a doppleganger";
+			Body = 0x309;
+			BaseSoundID = 0x451;
+		}
+
+		public SummonedDoppleganger( Serial serial ) : base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedFrostSpider() : base()
+		{
+			Name = "a frost spider";
+			Body = 20;
+			BaseSoundID = 0x388;
+		}
+
+		public SummonedFrostSpider( Serial serial ) : base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedGreatHart() : base()
+		{
+			Name = "a great hart";
+			Body = 0xEA;
+			BaseSoundID = 0x82;
+		}
+
+		public SummonedGreatHart( Serial serial ) : base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedLavaSerpent() : base()
+		{
+			Name = "a lava serpent";
+			Body = 90;
+			BaseSoundID = 219;
+		}
+
+		public SummonedLavaSerpent( Serial serial ) : base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedOrcBrute() : base()
+		{
+			Body = 189;
+			Name = "an orc brute";
+			BaseSoundID = 0x45A;
+		}
+
+		public SummonedOrcBrute( Serial serial ) : base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedPanther() : base()
+		{
+			Name = "a panther";
+			Body = 0xD6;
+			Hue = 0x901;
+			BaseSoundID = 0x462;
+		}
+
+		public SummonedPanther( Serial serial ) : base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedSheep() : base()
+		{
+			Name = "a sheep";
+			Body = 0xCF;
+			BaseSoundID = 0xD6;
+		}
+
+		public SummonedSheep( Serial serial ) : base( serial )
+		{
+		}
+		
+
+		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
+	{
+		[Constructable]
+		public SummonedSkeletalKnight() : base()
+		{
+			Name = "a skeletal knight";
+			Body = 147;
+			BaseSoundID = 451;
+		}
+
+		public SummonedSkeletalKnight( Serial serial ) : base( serial )
+		{
+		}
+
+		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
+	{
+		[Constructable]
+		public SummonedVorpalBunny() : base()
+		{
+			Name = "a vorpal bunny";
+			Body = 205;
+			Hue = 0x480;
+			BaseSoundID = 0xC9;
+
+			Timer.DelayCall( TimeSpan.FromMinutes( 30.0 ), new TimerCallback( BeginTunnel ) );
+		}
+
+		public SummonedVorpalBunny( Serial serial ) : base( serial )
+		{
+		}
+
+		public virtual void BeginTunnel()
+		{
+			if ( Deleted )
+				return;
+
+			new 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 ), new TimerCallback( 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
+	{
+		[Constructable]
+		public SummonedWailingBanshee() : base()
+		{
+			Name = "a wailing banshee";
+			Body = 310;
+			BaseSoundID = 0x482;
+		}
+
+		public SummonedWailingBanshee( Serial serial ) : base( serial )
+		{
+		}
+
+		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();
+		}
+	}
+}