#W# Initial Commit: Avatars Conquest

Scripts/Items/Skill Items/Magical/BlankScroll.cs

@@ -0,0 +1,38 @@
+using System;
+
+namespace Server.Items
+{
+	public class BlankScroll : Item
+	{
+		[Constructable]
+		public BlankScroll() : this( 1 )
+		{
+		}
+
+		[Constructable]
+		public BlankScroll( int amount ) : base( 0xEF3 )
+		{
+			Stackable = true;
+			Weight = 1.0;
+			Amount = amount;
+		}
+
+		public BlankScroll( 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/Skill Items/Magical/Bottle.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace Server.Items
+{
+	public class Bottle : Item
+	{
+		[Constructable]
+		public Bottle() : this( 1 )
+		{
+		}
+
+		[Constructable]
+		public Bottle( int amount ) : base( 0xF0E )
+		{
+			Stackable = true;
+			Weight = 1.0;
+			Amount = amount;
+		}
+
+		public Bottle( 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/Skill Items/Magical/MagicRune.cs

@@ -0,0 +1,236 @@
+using System;
+using Server.Network;
+using Server.Prompts;
+using Server.Multis;
+using Server.Regions;
+
+namespace Server.Items
+{
+	public class MagicRune : Item, IDyable
+	{
+		private string m_Description;
+		private bool m_Marked;
+		private Point3D m_Target;
+		private Map m_TargetMap;
+		private BaseHouse m_House;
+		private Mobile m_Owner;
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+			writer.Write( (int) 0 ); // version
+
+			writer.Write( (Item) m_House );
+			writer.Write( (string) m_Description );
+			writer.Write( (bool) m_Marked );
+			writer.Write( (Point3D) m_Target );
+			writer.Write( (Map) m_TargetMap );
+			writer.Write( (Mobile) m_Owner );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+			int version = reader.ReadInt();
+
+			m_House = reader.ReadItem() as BaseHouse;
+			m_Description = reader.ReadString();
+			m_Marked = reader.ReadBool();
+			m_Target = reader.ReadPoint3D();
+			m_TargetMap = reader.ReadMap();
+			m_Owner = reader.ReadMobile();
+		}
+
+		[CommandProperty( AccessLevel.Counselor, AccessLevel.GameMaster )]
+		public Mobile Owner
+		{
+			get
+			{
+				return m_Owner;
+			}
+			set{ m_Owner = value; InvalidateProperties(); }
+		}
+
+		[CommandProperty( AccessLevel.Counselor, AccessLevel.GameMaster )]
+		public BaseHouse House
+		{
+			get
+			{
+				if ( m_House != null && m_House.Deleted )
+					House = null;
+
+				return m_House;
+			}
+			set{ m_House = value; InvalidateProperties(); }
+		}
+
+		[CommandProperty( AccessLevel.Counselor, AccessLevel.GameMaster )]
+		public string Description
+		{
+			get
+			{
+				return m_Description;
+			}
+			set
+			{
+				m_Description = value;
+				InvalidateProperties();
+			}
+		}
+
+		[CommandProperty( AccessLevel.Counselor, AccessLevel.GameMaster )]
+		public bool Marked
+		{
+			get
+			{
+				return m_Marked;
+			}
+			set
+			{
+				if ( m_Marked != value )
+				{
+					m_Marked = value;
+					InvalidateProperties();
+				}
+			}
+		}
+
+		[CommandProperty( AccessLevel.Counselor, AccessLevel.GameMaster )]
+		public Point3D Target
+		{
+			get
+			{
+				return m_Target;
+			}
+			set
+			{
+				m_Target = value;
+			}
+		}
+
+		[CommandProperty( AccessLevel.Counselor, AccessLevel.GameMaster )]
+		public Map TargetMap
+		{
+			get
+			{
+				return m_TargetMap;
+			}
+			set
+			{
+				if ( m_TargetMap != value )
+				{
+					m_TargetMap = value;
+					InvalidateProperties();
+				}
+			}
+		}
+
+		public virtual bool Dye( Mobile from, DyeTub sender )
+		{
+			if ( Deleted )
+				return false;
+			else if ( RootParent is Mobile && from != RootParent )
+				return false;
+
+			Hue = sender.DyedHue;
+
+			return true;
+		}
+
+		public void Mark( Mobile m )
+		{
+			m_Marked = true;
+			m_Owner = m;
+
+			bool setDesc = false;
+
+			m_House = null;
+			m_Target = m.Location;
+			m_TargetMap = m.Map;
+
+			if( !setDesc )
+				m_Description = BaseRegion.GetRuneNameFor( Region.Find( m_Target, m_TargetMap ) );
+
+			ItemID = 0x1f15;
+			InvalidateProperties();
+		}
+
+		private const string RuneFormat = "a rune for {0}";
+
+		public override void GetProperties( ObjectPropertyList list )
+		{
+			base.GetProperties( list );
+
+			if ( m_Marked )
+			{
+				string desc;
+
+				if ( (desc = m_Description) == null || (desc = desc.Trim()).Length == 0 )
+					desc = "an unknown location";
+
+				list.Add( ("{0}"), String.Format( RuneFormat, desc ) );
+			}
+		}
+
+        public override void AddNameProperties(ObjectPropertyList list)
+		{
+            base.AddNameProperties(list);
+			if ( Owner != null ){ list.Add( 1070722, "Belongs to " + Owner.Name + "" ); }
+        }
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			int number;
+
+			if ( !IsChildOf( from.Backpack ) )
+			{
+				number = 1042001; // That must be in your pack for you to use it.
+			}
+			else if ( House != null )
+			{
+				number = 1062399; // You cannot edit the description for this rune.
+			}
+			else if ( m_Marked )
+			{
+				number = 501804; // Please enter a description for this marked object.
+
+				from.Prompt = new RenamePrompt( this );
+			}
+			else
+			{
+				number = 501805; // That rune is not yet marked.
+			}
+
+			from.SendLocalizedMessage( number );
+		}
+
+		private class RenamePrompt : Prompt
+		{
+			private MagicRune m_Rune;
+
+			public RenamePrompt( MagicRune rune )
+			{
+				m_Rune = rune;
+			}
+
+			public override void OnResponse( Mobile from, string text )
+			{
+				if ( m_Rune.House == null && m_Rune.Marked )
+				{
+					m_Rune.Description = text;
+					from.SendLocalizedMessage( 1010474 ); // The etching on the rune has been changed.
+				}
+			}
+		}
+
+		[Constructable]
+		public MagicRune() : base( 0x1F14 )
+		{
+			Weight = 1.0;
+		}
+
+		public MagicRune( Serial serial ) : base( serial )
+		{
+		}
+	}
+}

Scripts/Items/Skill Items/Magical/Magicgate.cs

@@ -0,0 +1,412 @@
+using System;
+using System.Collections;
+using Server.Misc;
+using Server.Mobiles;
+using Server.Network;
+using Server.Gumps;
+using Server.Regions;
+
+namespace Server.Items
+{
+	[DispellableFieldAttribute]
+	public class Magicgate : Item
+	{
+		private Point3D m_Target;
+		private Map m_TargetMap;
+		private bool m_bDispellable;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public Point3D Target
+		{
+			get
+			{
+				return m_Target;
+			}
+			set
+			{
+				m_Target = value;
+			}
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public Map TargetMap
+		{
+			get
+			{
+				return m_TargetMap;
+			}
+			set
+			{
+				m_TargetMap = value;
+			}
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public bool Dispellable
+		{
+			get
+			{
+				return m_bDispellable;
+			}
+			set
+			{
+				m_bDispellable = value;
+			}
+		}
+
+		[Constructable]
+		public Magicgate() : this( Point3D.Zero, null )
+		{
+			m_bDispellable = true;
+		}
+
+		[Constructable]
+		public Magicgate(bool bDispellable) : this( Point3D.Zero, null )
+		{
+			m_bDispellable = bDispellable;
+		}
+
+		[Constructable]
+		public Magicgate( Point3D target, Map targetMap ) : base( 0xF6C )
+		{
+			Movable = false;
+			Light = LightType.Circle300;
+
+			m_Target = target;
+			m_TargetMap = targetMap;
+		}
+
+		public Magicgate( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( !from.Player )
+				return;
+
+			if ( from.InRange( GetWorldLocation(), 1 ) )
+				CheckGate( from, 1 );
+			else
+				from.SendLocalizedMessage( 500446 ); // That is too far away.
+		}
+
+		public override bool OnMoveOver( Mobile m )
+		{
+			if ( m.Player )
+				CheckGate( m, 0 );
+
+			return true;
+		}
+
+		public virtual void CheckGate( Mobile m, int range )
+		{
+			new DelayTimer( m, this, range ).Start();
+		}
+
+		public virtual void OnGateUsed( Mobile m )
+		{
+		}
+
+		public virtual void UseGate( Mobile m )
+		{
+			ClientFlags flags = m.NetState == null ? ClientFlags.None : m.NetState.Flags;
+
+			if ( m.Spell != null )
+			{
+				m.SendLocalizedMessage( 1049616 ); // You are too busy to do that at the moment.
+			}
+			else if ( m_TargetMap != null && m_TargetMap != Map.Internal )
+			{
+				BaseCreature.TeleportPets( m, m_Target, m_TargetMap );
+
+				m.MoveToWorld( m_Target, m_TargetMap );
+
+				if ( m.AccessLevel == AccessLevel.Player || !m.Hidden )
+					m.PlaySound( 0x1FE );
+
+				OnGateUsed( m );
+			}
+			else
+			{
+				m.SendMessage( "This moongate does not seem to go anywhere." );
+			}
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 1 ); // version
+
+			writer.Write( m_Target );
+			writer.Write( m_TargetMap );
+			
+			// Version 1
+			writer.Write( m_bDispellable );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			m_Target = reader.ReadPoint3D();
+			m_TargetMap = reader.ReadMap();
+
+			if ( version >= 1 )
+				m_bDispellable = reader.ReadBool();
+		}
+
+		public virtual bool ValidateUse( Mobile from, bool message )
+		{
+			if ( from.Deleted || this.Deleted )
+				return false;
+
+			if ( from.Map != this.Map || !from.InRange( this, 1 ) )
+			{
+				if ( message )
+					from.SendLocalizedMessage( 500446 ); // That is too far away.
+
+				return false;
+			}
+
+			return true;
+		}
+
+		public virtual void BeginConfirmation( Mobile from )
+		{
+			if ( IsInTown( from.Location, from.Map ) && !IsInTown( m_Target, m_TargetMap ) )
+			{
+				if ( from.AccessLevel == AccessLevel.Player || !from.Hidden )
+					from.Send( new PlaySound( 0x20E, from.Location ) );
+				from.CloseGump( typeof( MagicgateConfirmGump ) );
+				from.SendGump( new MagicgateConfirmGump( from, this ) );
+			}
+			else
+			{
+				EndConfirmation( from );
+			}
+		}
+
+		public virtual void EndConfirmation( Mobile from )
+		{
+			if ( !ValidateUse( from, true ) )
+				return;
+
+			UseGate( from );
+		}
+
+		public virtual void DelayCallback( Mobile from, int range )
+		{
+			if ( !ValidateUse( from, false ) || !from.InRange( this, range ) )
+				return;
+
+			if ( m_TargetMap != null )
+				BeginConfirmation( from );
+			else
+				from.SendMessage( "This moongate does not seem to go anywhere." );
+		}
+
+		public static bool IsInTown( Point3D p, Map map )
+		{
+			if ( map == null )
+				return false;
+
+			TownRegion reg = (TownRegion) Region.Find( p, map ).GetRegion( typeof( TownRegion ) );
+
+			return ( reg != null );
+		}
+
+		private class DelayTimer : Timer
+		{
+			private Mobile m_From;
+			private Magicgate m_Gate;
+			private int m_Range;
+
+			public DelayTimer( Mobile from, Magicgate gate, int range ) : base( TimeSpan.FromSeconds( 1.0 ) )
+			{
+				m_From = from;
+				m_Gate = gate;
+				m_Range = range;
+			}
+
+			protected override void OnTick()
+			{
+				m_Gate.DelayCallback( m_From, m_Range );
+			}
+		}
+	}
+
+	public class ConfirmationMagicgate : Magicgate
+	{
+		private int m_GumpWidth;
+		private int m_GumpHeight;
+
+		private int m_TitleColor;
+		private int m_MessageColor;
+
+		private int m_TitleNumber;
+		private int m_MessageNumber;
+
+		private string m_MessageString;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int GumpWidth
+		{
+			get{ return m_GumpWidth; }
+			set{ m_GumpWidth = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int GumpHeight
+		{
+			get{ return m_GumpHeight; }
+			set{ m_GumpHeight = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int TitleColor
+		{
+			get{ return m_TitleColor; }
+			set{ m_TitleColor = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int MessageColor
+		{
+			get{ return m_MessageColor; }
+			set{ m_MessageColor = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int TitleNumber
+		{
+			get{ return m_TitleNumber; }
+			set{ m_TitleNumber = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int MessageNumber
+		{
+			get{ return m_MessageNumber; }
+			set{ m_MessageNumber = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public string MessageString
+		{
+			get{ return m_MessageString; }
+			set{ m_MessageString = value; }
+		}
+
+		[Constructable]
+		public ConfirmationMagicgate() : this( Point3D.Zero, null )
+		{
+		}
+
+		[Constructable]
+		public ConfirmationMagicgate( Point3D target, Map targetMap ) : base( target, targetMap )
+		{
+		}
+
+		public ConfirmationMagicgate( Serial serial ) : base( serial )
+		{
+		}
+
+		public virtual void Warning_Callback( Mobile from, bool okay, object state )
+		{
+			if ( okay )
+				EndConfirmation( from );
+		}
+
+		public override void BeginConfirmation( Mobile from )
+		{
+			if ( m_GumpWidth > 0 && m_GumpHeight > 0 && m_TitleNumber > 0 && (m_MessageNumber > 0 || m_MessageString != null) )
+			{
+				from.CloseGump( typeof( WarningGump ) );
+				from.SendGump( new WarningGump( m_TitleNumber, m_TitleColor, m_MessageString == null ? (object)m_MessageNumber : (object)m_MessageString, m_MessageColor, m_GumpWidth, m_GumpHeight, new WarningGumpCallback( Warning_Callback ), from ) );
+			}
+			else
+			{
+				base.BeginConfirmation( from );
+			}
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+
+			writer.WriteEncodedInt( m_GumpWidth );
+			writer.WriteEncodedInt( m_GumpHeight );
+
+			writer.WriteEncodedInt( m_TitleColor );
+			writer.WriteEncodedInt( m_MessageColor );
+
+			writer.WriteEncodedInt( m_TitleNumber );
+			writer.WriteEncodedInt( m_MessageNumber );
+
+			writer.Write( m_MessageString );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 0:
+				{
+					m_GumpWidth = reader.ReadEncodedInt();
+					m_GumpHeight = reader.ReadEncodedInt();
+
+					m_TitleColor = reader.ReadEncodedInt();
+					m_MessageColor = reader.ReadEncodedInt();
+
+					m_TitleNumber = reader.ReadEncodedInt();
+					m_MessageNumber = reader.ReadEncodedInt();
+
+					m_MessageString = reader.ReadString();
+
+					break;
+				}
+			}
+		}
+	}
+
+	public class MagicgateConfirmGump : Gump
+	{
+		private Mobile m_From;
+		private Magicgate m_Gate;
+
+		public MagicgateConfirmGump( Mobile from, Magicgate gate ) : base( 20, 30 )
+		{
+			m_From = from;
+			m_Gate = gate;
+
+			AddPage( 0 );
+
+			AddBackground( 0, 0, 420, 400, 5054 );
+			AddBackground( 10, 10, 400, 380, 3000 );
+
+			AddHtml( 20, 40, 380, 60, @"Dost thou wish to step into the moongate? Continue to enter the gate, Cancel to stay here", false, false );
+
+			AddHtmlLocalized( 55, 110, 290, 20, 1011012, false, false ); // CANCEL
+			AddButton( 20, 110, 4005, 4007, 0, GumpButtonType.Reply, 0 );
+
+			AddHtmlLocalized( 55, 140, 290, 40, 1011011, false, false ); // CONTINUE
+			AddButton( 20, 140, 4005, 4007, 1, GumpButtonType.Reply, 0 );
+		}
+
+		public override void OnResponse( NetState state, RelayInfo info )
+		{
+			if ( info.ButtonID == 1 )
+				m_Gate.EndConfirmation( m_From );
+		}
+	}
+}

Scripts/Items/Skill Items/Magical/PotionKeg.cs

@@ -0,0 +1,344 @@
+using System;
+using Server;
+using Server.Items;
+
+namespace Server.Items
+{
+	public class PotionKeg : Item
+	{
+		private PotionEffect m_Type;
+		private int m_Held;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int Held
+		{
+			get
+			{
+				return m_Held;
+			}
+			set
+			{
+				if ( m_Held != value )
+				{
+					m_Held = value;
+					UpdateWeight();
+					InvalidateProperties();
+				}
+			}
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public PotionEffect Type
+		{
+			get
+			{
+				return m_Type;
+			}
+			set
+			{
+				m_Type = value;
+				InvalidateProperties();
+			}
+		}
+
+		[Constructable]
+		public PotionKeg() : base( 0x1940 )
+		{
+			UpdateWeight();
+		}
+
+		public virtual void UpdateWeight()
+		{
+			int held = Math.Max( 0, Math.Min( m_Held, 100 ) );
+
+			this.Weight = 20 + ((held * 80) / 100);
+		}
+
+		public PotionKeg( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 1 ); // version
+
+			writer.Write( (int) m_Type );
+			writer.Write( (int) m_Held );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 1:
+				case 0:
+				{
+					m_Type = (PotionEffect)reader.ReadInt();
+					m_Held = reader.ReadInt();
+
+					break;
+				}
+			}
+
+			if ( version < 1 )
+				Timer.DelayCall( TimeSpan.Zero, new TimerCallback( UpdateWeight ) );
+		}
+
+		public override int LabelNumber
+		{ 
+			get
+			{ 
+				if ( m_Held == 0 )
+					return 1041084; // A specially lined keg for potions.
+				else
+					return ( 1041620 + (int)m_Type ); 
+			} 
+		}
+
+		public override void GetProperties( ObjectPropertyList list )
+		{
+			base.GetProperties( list );
+
+			int number;
+
+			if ( m_Held <= 0 )
+				number = 502246; // The keg is empty.
+			else if ( m_Held < 5 )
+				number = 502248; // The keg is nearly empty.
+			else if ( m_Held < 20 )
+				number = 502249; // The keg is not very full.
+			else if ( m_Held < 30 )
+				number = 502250; // The keg is about one quarter full.
+			else if ( m_Held < 40 )
+				number = 502251; // The keg is about one third full.
+			else if ( m_Held < 47 )
+				number = 502252; // The keg is almost half full.
+			else if ( m_Held < 54 )
+				number = 502254; // The keg is approximately half full.
+			else if ( m_Held < 70 )
+				number = 502253; // The keg is more than half full.
+			else if ( m_Held < 80 )
+				number = 502255; // The keg is about three quarters full.
+			else if ( m_Held < 96 )
+				number = 502256; // The keg is very full.
+			else if ( m_Held < 100 )
+				number = 502257; // The liquid is almost to the top of the keg.
+			else
+				number = 502258; // The keg is completely full.
+
+			list.Add( number );
+		}
+
+		public override void OnSingleClick( Mobile from )
+		{
+			base.OnSingleClick( from );
+
+			int number;
+
+			if ( m_Held <= 0 )
+				number = 502246; // The keg is empty.
+			else if ( m_Held < 5 )
+				number = 502248; // The keg is nearly empty.
+			else if ( m_Held < 20 )
+				number = 502249; // The keg is not very full.
+			else if ( m_Held < 30 )
+				number = 502250; // The keg is about one quarter full.
+			else if ( m_Held < 40 )
+				number = 502251; // The keg is about one third full.
+			else if ( m_Held < 47 )
+				number = 502252; // The keg is almost half full.
+			else if ( m_Held < 54 )
+				number = 502254; // The keg is approximately half full.
+			else if ( m_Held < 70 )
+				number = 502253; // The keg is more than half full.
+			else if ( m_Held < 80 )
+				number = 502255; // The keg is about three quarters full.
+			else if ( m_Held < 96 )
+				number = 502256; // The keg is very full.
+			else if ( m_Held < 100 )
+				number = 502257; // The liquid is almost to the top of the keg.
+			else
+				number = 502258; // The keg is completely full.
+
+			this.LabelTo( from, number );
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( from.InRange( GetWorldLocation(), 2 ) )
+			{
+				if ( m_Held > 0 )
+				{
+					Container pack = from.Backpack;
+
+					if ( pack != null && pack.ConsumeTotal( typeof( Bottle ), 1 ) )
+					{
+						from.SendLocalizedMessage( 502242 ); // You pour some of the keg's contents into an empty bottle...
+
+						BasePotion pot = FillBottle();
+
+						if ( pack.TryDropItem( from, pot, false ) )
+						{
+							from.SendLocalizedMessage( 502243 ); // ...and place it into your backpack.
+							from.PlaySound( 0x240 );
+
+							if ( --Held == 0 )
+								from.SendLocalizedMessage( 502245 ); // The keg is now empty.
+						}
+						else
+						{
+							from.SendLocalizedMessage( 502244 ); // ...but there is no room for the bottle in your backpack.
+							pot.Delete();
+						}
+					}
+					else
+					{
+						// TODO: Target a bottle
+					}
+				}
+				else
+				{
+					from.SendLocalizedMessage( 502246 ); // The keg is empty.
+				}
+			}
+			else
+			{
+				from.LocalOverheadMessage( Network.MessageType.Regular, 0x3B2, 1019045 ); // I can't reach that.
+			}
+		}
+
+		public override bool OnDragDrop( Mobile from, Item item )
+		{
+			if ( item is BasePotion )
+			{
+				BasePotion pot = (BasePotion)item;
+                int toHold = Math.Min( 100 - m_Held, pot.Amount );
+
+                
+				if ( toHold <= 0 )
+				{
+					from.SendLocalizedMessage( 502233 ); // The keg will not hold any more!
+					return false;
+				}
+				else if ( m_Held == 0 )
+				{
+					if ( GiveBottle( from, toHold ) )
+					{
+						m_Type = pot.PotionEffect;
+						Held = toHold;
+
+						from.PlaySound( 0x240 );
+
+						from.SendLocalizedMessage( 502237 ); // You place the empty bottle in your backpack.
+
+                        item.Consume( toHold );
+
+						if( !item.Deleted )
+							item.Bounce( from );
+
+						return true;
+					}
+					else
+					{
+						from.SendLocalizedMessage( 502238 ); // You don't have room for the empty bottle in your backpack.
+						return false;
+					}
+				}
+				else if ( pot.PotionEffect != m_Type )
+				{
+					from.SendLocalizedMessage( 502236 ); // You decide that it would be a bad idea to mix different types of potions.
+					return false;
+				}
+				else
+				{
+					if ( GiveBottle( from, toHold ) )
+					{
+						Held += toHold;
+
+						from.PlaySound( 0x240 );
+
+						from.SendLocalizedMessage( 502237 ); // You place the empty bottle in your backpack.
+
+						item.Consume( toHold );
+
+						if( !item.Deleted )
+							item.Bounce( from );
+
+						return true;
+					}
+					else
+					{
+						from.SendLocalizedMessage( 502238 ); // You don't have room for the empty bottle in your backpack.
+						return false;
+					}
+				}
+			}
+			else
+			{
+				from.SendLocalizedMessage( 502232 ); // The keg is not designed to hold that type of object.
+				return false;
+			}
+		}
+
+		public bool GiveBottle( Mobile m, int amount )
+		{
+			Container pack = m.Backpack;
+
+			Bottle bottle = new Bottle( amount );
+
+			if ( pack == null || !pack.TryDropItem( m, bottle, false ) )
+			{
+				bottle.Delete();
+				return false;
+			}
+
+			return true;
+		}
+
+		public BasePotion FillBottle()
+		{
+			switch ( m_Type )
+			{
+				default:
+				case PotionEffect.Nightsight:			return new NightSightPotion();
+
+				case PotionEffect.CureLesser:			return new LesserCurePotion();
+				case PotionEffect.Cure:				return new CurePotion();
+				case PotionEffect.CureGreater:			return new GreaterCurePotion();
+
+				case PotionEffect.Agility:			return new AgilityPotion();
+				case PotionEffect.AgilityGreater:		return new GreaterAgilityPotion();
+
+				case PotionEffect.Strength:			return new StrengthPotion();
+				case PotionEffect.StrengthGreater:		return new GreaterStrengthPotion();
+
+				case PotionEffect.PoisonLesser:			return new LesserPoisonPotion();
+				case PotionEffect.Poison:			return new PoisonPotion();
+				case PotionEffect.PoisonGreater:		return new GreaterPoisonPotion();
+				case PotionEffect.PoisonDeadly:			return new DeadlyPoisonPotion();
+
+				case PotionEffect.Refresh:			return new RefreshPotion();
+				case PotionEffect.RefreshTotal:			return new TotalRefreshPotion();
+
+				case PotionEffect.HealLesser:			return new LesserHealPotion();
+				case PotionEffect.Heal:				return new HealPotion();
+				case PotionEffect.HealGreater:			return new GreaterHealPotion();
+
+				case PotionEffect.ExplosionLesser:		return new LesserExplosionPotion();
+				case PotionEffect.Explosion:			return new ExplosionPotion();
+				case PotionEffect.ExplosionGreater:		return new GreaterExplosionPotion();
+			}
+		}
+
+		public static void Initialize()
+		{
+			TileData.ItemTable[0x1940].Height = 4;
+		}
+	}
+}