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

Scripts/Multis/Boats/BaseBoatDeed.cs

@@ -0,0 +1,183 @@
+using System;
+using Server;
+using Server.Regions;
+using Server.Targeting;
+using Server.Engines.CannedEvil;
+using Server.Network;
+
+namespace Server.Multis
+{
+	public abstract class BaseBoatDeed : Item
+	{
+		private int m_MultiID;
+		private Point3D m_Offset;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int MultiID{ get{ return m_MultiID; } set{ m_MultiID = value; } }
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public Point3D Offset{ get{ return m_Offset; } set{ m_Offset = value; } }
+
+		public BaseBoatDeed( int id, Point3D offset ) : base( 0x14F2 )
+		{
+			Weight = 1.0;
+
+			if ( !Core.AOS )
+				LootType = LootType.Newbied;
+
+			m_MultiID = id;
+			m_Offset = offset;
+		}
+
+		public BaseBoatDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+
+			writer.Write( m_MultiID );
+			writer.Write( m_Offset );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 0:
+				{
+					m_MultiID = reader.ReadInt();
+					m_Offset = reader.ReadPoint3D();
+
+					break;
+				}
+			}
+
+			if ( Weight == 0.0 )
+				Weight = 1.0;
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( !IsChildOf( from.Backpack ) )
+			{
+				from.SendLocalizedMessage( 1042001 ); // That must be in your pack for you to use it.
+			}
+			else if ( from.AccessLevel < AccessLevel.GameMaster && (from.Map == Map.Ilshenar || from.Map == Map.Malas) )
+			{
+				from.SendLocalizedMessage( 1010567, null, 0x25 ); // You may not place a boat from this location.
+			}
+			else
+			{
+				if ( Core.SE )
+					from.SendLocalizedMessage( 502482 ); // Where do you wish to place the ship?
+				else
+					from.LocalOverheadMessage( MessageType.Regular, 0x3B2, 502482 ); // Where do you wish to place the ship?
+
+				from.Target = new InternalTarget( this );
+			}
+		}
+
+		public abstract BaseBoat Boat{ get; }
+
+		public void OnPlacement( Mobile from, Point3D p )
+		{
+			if ( Deleted )
+			{
+				return;
+			}
+			else if ( !IsChildOf( from.Backpack ) )
+			{
+				from.SendLocalizedMessage( 1042001 ); // That must be in your pack for you to use it.
+			}
+			else
+			{
+				Map map = from.Map;
+
+				if ( map == null )
+					return;
+
+				if ( from.AccessLevel < AccessLevel.GameMaster && (map == Map.Ilshenar || map == Map.Malas) )
+				{
+					from.SendLocalizedMessage( 1043284 ); // A ship can not be created here.
+					return;
+				}
+
+				if ( from.Region.IsPartOf( typeof( HouseRegion ) ) || BaseBoat.FindBoatAt( from, from.Map ) != null )
+				{
+					from.SendLocalizedMessage( 1010568, null, 0x25 ); // You may not place a ship while on another ship or inside a house.
+					return;
+				}
+
+				BaseBoat boat = Boat;
+
+				if ( boat == null )
+					return;
+
+				p = new Point3D( p.X - m_Offset.X, p.Y - m_Offset.Y, p.Z - m_Offset.Z );
+
+				if ( BaseBoat.IsValidLocation( p, map ) && boat.CanFit( p, map, boat.ItemID ) )
+				{
+					Delete();
+
+					boat.Owner = from;
+					boat.Anchored = true;
+
+					uint keyValue = boat.CreateKeys( from );
+
+					if ( boat.PPlank != null )
+						boat.PPlank.KeyValue = keyValue;
+
+					if ( boat.SPlank != null )
+						boat.SPlank.KeyValue = keyValue;
+
+					boat.MoveToWorld( p, map );
+				}
+				else
+				{
+					boat.Delete();
+					from.SendLocalizedMessage( 1043284 ); // A ship can not be created here.
+				}
+			}
+		}
+
+		private class InternalTarget : MultiTarget
+		{
+			private BaseBoatDeed m_Deed;
+
+			public InternalTarget( BaseBoatDeed deed ) : base( deed.MultiID, deed.Offset )
+			{
+				m_Deed = deed;
+			}
+
+			protected override void OnTarget( Mobile from, object o )
+			{
+				IPoint3D ip = o as IPoint3D;
+
+				if ( ip != null )
+				{
+					if ( ip is Item )
+						ip = ((Item)ip).GetWorldTop();
+
+					Point3D p = new Point3D( ip );
+
+					Region region = Region.Find( p, from.Map );
+
+					if ( region.IsPartOf( typeof( DungeonRegion ) ) )
+						from.SendLocalizedMessage( 502488 ); // You can not place a ship inside a dungeon.
+					else if ( region.IsPartOf( typeof( HouseRegion ) ) || region.IsPartOf( typeof( ChampionSpawnRegion ) ) )
+						from.SendLocalizedMessage( 1042549 ); // A boat may not be placed in this area.
+					else
+						m_Deed.OnPlacement( from, p );
+				}
+			}
+		}
+	}
+}

Scripts/Multis/Boats/BaseDockedBoat.cs

@@ -0,0 +1,193 @@
+using System;
+using Server;
+using Server.Regions;
+using Server.Targeting;
+using Server.Engines.CannedEvil;
+
+namespace Server.Multis
+{
+	public abstract class BaseDockedBoat : Item
+	{
+		private int m_MultiID;
+		private Point3D m_Offset;
+		private string m_ShipName;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int MultiID{ get{ return m_MultiID; } set{ m_MultiID = value; } }
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public Point3D Offset{ get{ return m_Offset; } set{ m_Offset = value; } }
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public string ShipName{ get{ return m_ShipName; } set{ m_ShipName = value; InvalidateProperties(); } }
+
+		public BaseDockedBoat( int id, Point3D offset, BaseBoat boat ) : base( 0x14F4 )
+		{
+			Weight = 1.0;
+			LootType = LootType.Blessed;
+
+			m_MultiID = id;
+			m_Offset = offset;
+
+			m_ShipName = boat.ShipName;
+		}
+
+		public BaseDockedBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 1 ); // version
+
+			writer.Write( m_MultiID );
+			writer.Write( m_Offset );
+			writer.Write( m_ShipName );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 1:
+				case 0:
+				{
+					m_MultiID = reader.ReadInt();
+					m_Offset = reader.ReadPoint3D();
+					m_ShipName = reader.ReadString();
+
+					if ( version == 0 )
+						reader.ReadUInt();
+
+					break;
+				}
+			}
+
+			if ( LootType == LootType.Newbied )
+				LootType = LootType.Blessed;
+
+			if ( Weight == 0.0 )
+				Weight = 1.0;
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( !IsChildOf( from.Backpack ) )
+			{
+				from.SendLocalizedMessage( 1042001 ); // That must be in your pack for you to use it.
+			}
+			else
+			{
+				from.SendLocalizedMessage( 502482 ); // Where do you wish to place the ship?
+
+				from.Target = new InternalTarget( this );
+			}
+		}
+
+		public abstract BaseBoat Boat{ get; }
+
+		public override void AddNameProperty( ObjectPropertyList list )
+		{
+			if ( m_ShipName != null )
+				list.Add( m_ShipName );
+			else
+				base.AddNameProperty( list );
+		}
+
+		public override void OnSingleClick( Mobile from )
+		{
+			if ( m_ShipName != null )
+				LabelTo( from, m_ShipName );
+			else
+				base.OnSingleClick( from );
+		}
+
+		public void OnPlacement( Mobile from, Point3D p )
+		{
+			if ( Deleted )
+			{
+				return;
+			}
+			else if ( !IsChildOf( from.Backpack ) )
+			{
+				from.SendLocalizedMessage( 1042001 ); // That must be in your pack for you to use it.
+			}
+			else
+			{
+				Map map = from.Map;
+
+				if ( map == null )
+					return;
+
+				BaseBoat boat = Boat;
+
+				if ( boat == null )
+					return;
+
+				p = new Point3D( p.X - m_Offset.X, p.Y - m_Offset.Y, p.Z - m_Offset.Z );
+
+				if ( BaseBoat.IsValidLocation( p, map ) && boat.CanFit( p, map, boat.ItemID ) && map != Map.Ilshenar && map != Map.Malas )
+				{
+					Delete();
+
+					boat.Owner = from;
+					boat.Anchored = true;
+					boat.ShipName = m_ShipName;
+
+					uint keyValue = boat.CreateKeys( from );
+
+					if ( boat.PPlank != null )
+						boat.PPlank.KeyValue = keyValue;
+
+					if ( boat.SPlank != null )
+						boat.SPlank.KeyValue = keyValue;
+
+					boat.MoveToWorld( p, map );
+				}
+				else
+				{
+					boat.Delete();
+					from.SendLocalizedMessage( 1043284 ); // A ship can not be created here.
+				}
+			}
+		}
+
+		private class InternalTarget : MultiTarget
+		{
+			private BaseDockedBoat m_Model;
+
+			public InternalTarget( BaseDockedBoat model ) : base( model.MultiID, model.Offset )
+			{
+				m_Model = model;
+			}
+
+			protected override void OnTarget( Mobile from, object o )
+			{
+				IPoint3D ip = o as IPoint3D;
+
+				if ( ip != null )
+				{
+					if ( ip is Item )
+						ip = ((Item)ip).GetWorldTop();
+
+					Point3D p = new Point3D( ip );
+
+					Region region = Region.Find( p, from.Map );
+
+					if ( region.IsPartOf( typeof( DungeonRegion ) ) )
+						from.SendLocalizedMessage( 502488 ); // You can not place a ship inside a dungeon.
+					else if ( region.IsPartOf( typeof( HouseRegion ) ) || region.IsPartOf( typeof( ChampionSpawnRegion ) ) )
+						from.SendLocalizedMessage( 1042549 ); // A boat may not be placed in this area.
+					else
+						m_Model.OnPlacement( from, p );
+				}
+			}
+		}
+	}
+}

Scripts/Multis/Boats/ConfirmDryDockGump.cs

@@ -0,0 +1,40 @@
+using System;
+using Server;
+using Server.Gumps;
+using Server.Network;
+
+namespace Server.Multis
+{
+	public class ConfirmDryDockGump : Gump
+	{
+		private Mobile m_From;
+		private BaseBoat m_Boat;
+
+		public ConfirmDryDockGump( Mobile from, BaseBoat boat ) : base( 150, 200 )
+		{
+			m_From = from;
+			m_Boat = boat;
+
+			m_From.CloseGump( typeof( ConfirmDryDockGump ) );
+
+			AddPage( 0 );
+
+			AddBackground( 0, 0, 220, 170, 5054 );
+			AddBackground( 10, 10, 200, 150, 3000 );
+
+			AddHtmlLocalized( 20, 20, 180, 80, 1018319, true, false ); // Do you wish to dry dock this boat?
+
+			AddHtmlLocalized( 55, 100, 140, 25, 1011011, false, false ); // CONTINUE
+			AddButton( 20, 100, 4005, 4007, 2, GumpButtonType.Reply, 0 );
+
+			AddHtmlLocalized( 55, 125, 140, 25, 1011012, false, false ); // CANCEL
+			AddButton( 20, 125, 4005, 4007, 1, GumpButtonType.Reply, 0 );
+		}
+
+		public override void OnResponse( NetState state, RelayInfo info )
+		{
+			if ( info.ButtonID == 2 )
+				m_Boat.EndDryDock( m_From );
+		}
+	}
+}

Scripts/Multis/Boats/Hold.cs

@@ -0,0 +1,125 @@
+using System;
+using Server;
+using Server.Multis;
+using Server.Network;
+
+namespace Server.Items
+{
+	public class Hold : Container
+	{
+		private BaseBoat m_Boat;
+
+		public Hold( BaseBoat boat ) : base( 0x3EAE )
+		{
+			m_Boat = boat;
+			Movable = false;
+		}
+
+		public Hold( Serial serial ) : base( serial )
+		{
+		}
+
+		public void SetFacing( Direction dir )
+		{
+			switch ( dir )
+			{
+				case Direction.East:  ItemID = 0x3E65; break;
+				case Direction.West:  ItemID = 0x3E93; break;
+				case Direction.North: ItemID = 0x3EAE; break;
+				case Direction.South: ItemID = 0x3EB9; break;
+			}
+		}
+
+		public override bool OnDragDrop( Mobile from, Item item )
+		{
+			if ( m_Boat == null || !m_Boat.Contains( from ) || m_Boat.IsMoving )
+				return false;
+
+			return base.OnDragDrop( from, item );
+		}
+
+		public override bool OnDragDropInto( Mobile from, Item item, Point3D p )
+		{
+			if ( m_Boat == null || !m_Boat.Contains( from ) || m_Boat.IsMoving )
+				return false;
+
+			return base.OnDragDropInto( from, item, p );
+		}
+
+		public override bool CheckItemUse( Mobile from, Item item )
+		{
+			if ( item != this && (m_Boat == null || !m_Boat.Contains( from ) || m_Boat.IsMoving) )
+				return false;
+
+			return base.CheckItemUse( from, item );
+		}
+
+		public override bool CheckLift( Mobile from, Item item, ref LRReason reject )
+		{
+			if ( m_Boat == null || !m_Boat.Contains( from ) || m_Boat.IsMoving )
+				return false;
+
+			return base.CheckLift( from, item, ref reject );
+		}
+
+		public override void OnAfterDelete()
+		{
+			if ( m_Boat != null )
+				m_Boat.Delete();
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( m_Boat == null || !m_Boat.Contains( from ) )
+			{
+				if ( m_Boat.TillerMan != null )
+					m_Boat.TillerMan.Say( 502490 ); // You must be on the ship to open the hold.
+			}
+			else if ( m_Boat.IsMoving )
+			{
+				if ( m_Boat.TillerMan != null )
+					m_Boat.TillerMan.Say( 502491 ); // I can not open the hold while the ship is moving.
+			}
+			else
+			{
+				base.OnDoubleClick( from );
+			}
+		}
+
+		public override bool IsDecoContainer
+		{
+			get{ return false; }
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+
+			writer.Write( m_Boat );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 0:
+				{
+					m_Boat = reader.ReadItem() as BaseBoat;
+
+					if ( m_Boat == null || Parent != null )
+						Delete();
+
+					Movable = false;
+
+					break;
+				}
+			}
+		}
+	}
+}

Scripts/Multis/Boats/LargeBoat.cs

@@ -0,0 +1,103 @@
+using System;
+using Server;
+using Server.Items;
+
+namespace Server.Multis
+{
+	public class LargeBoat : BaseBoat
+	{
+		public override int NorthID{ get{ return 0x10; } }
+		public override int  EastID{ get{ return 0x11; } }
+		public override int SouthID{ get{ return 0x12; } }
+		public override int  WestID{ get{ return 0x13; } }
+
+		public override int HoldDistance{ get{ return 5; } }
+		public override int TillerManDistance{ get{ return -5; } }
+
+		public override Point2D StarboardOffset{ get{ return new Point2D(  2, -1 ); } }
+		public override Point2D      PortOffset{ get{ return new Point2D( -2, -1 ); } }
+
+		public override Point3D MarkOffset{ get{ return new Point3D( 0, 0, 3 ); } }
+
+		public override BaseDockedBoat DockedBoat{ get{ return new LargeDockedBoat( this ); } }
+
+		[Constructable]
+		public LargeBoat()
+		{
+		}
+
+		public LargeBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+
+	public class LargeBoatDeed : BaseBoatDeed
+	{
+		public override int LabelNumber{ get{ return 1041209; } } // large ship deed
+		public override BaseBoat Boat{ get{ return new LargeBoat(); } }
+
+		[Constructable]
+		public LargeBoatDeed() : base( 0x10, new Point3D( 0, -1, 0 ) )
+		{
+		}
+
+		public LargeBoatDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+
+	public class LargeDockedBoat : BaseDockedBoat
+	{
+		public override BaseBoat Boat{ get{ return new LargeBoat(); } }
+
+		public LargeDockedBoat( BaseBoat boat ) : base( 0x10, new Point3D( 0, -1, 0 ), boat )
+		{
+		}
+
+		public LargeDockedBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+}

Scripts/Multis/Boats/LargeDragonBoat.cs

@@ -0,0 +1,103 @@
+using System;
+using Server;
+using Server.Items;
+
+namespace Server.Multis
+{
+	public class LargeDragonBoat : BaseBoat
+	{
+		public override int NorthID{ get{ return 0x14; } }
+		public override int  EastID{ get{ return 0x15; } }
+		public override int SouthID{ get{ return 0x16; } }
+		public override int  WestID{ get{ return 0x17; } }
+
+		public override int HoldDistance{ get{ return 5; } }
+		public override int TillerManDistance{ get{ return -5; } }
+
+		public override Point2D StarboardOffset{ get{ return new Point2D(  2, -1 ); } }
+		public override Point2D      PortOffset{ get{ return new Point2D( -2, -1 ); } }
+
+		public override Point3D MarkOffset{ get{ return new Point3D( 0, 0, 3 ); } }
+
+		public override BaseDockedBoat DockedBoat{ get{ return new LargeDockedDragonBoat( this ); } }
+
+		[Constructable]
+		public LargeDragonBoat()
+		{
+		}
+
+		public LargeDragonBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+
+	public class LargeDragonBoatDeed : BaseBoatDeed
+	{
+		public override int LabelNumber{ get{ return 1041210; } }// large dragon ship deed
+		public override BaseBoat Boat{ get{ return new LargeDragonBoat(); } }
+
+		[Constructable]
+		public LargeDragonBoatDeed() : base( 0x14, new Point3D( 0, -1, 0 ) )
+		{
+		}
+
+		public LargeDragonBoatDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+
+	public class LargeDockedDragonBoat : BaseDockedBoat
+	{
+		public override BaseBoat Boat{ get{ return new LargeDragonBoat(); } }
+
+		public LargeDockedDragonBoat( BaseBoat boat ) : base( 0x14, new Point3D( 0, -1, 0 ), boat )
+		{
+		}
+
+		public LargeDockedDragonBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+}

Scripts/Multis/Boats/MediumBoat.cs

@@ -0,0 +1,103 @@
+using System;
+using Server;
+using Server.Items;
+
+namespace Server.Multis
+{
+	public class MediumBoat : BaseBoat
+	{
+		public override int NorthID{ get{ return 0x8; } }
+		public override int  EastID{ get{ return 0x9; } }
+		public override int SouthID{ get{ return 0xA; } }
+		public override int  WestID{ get{ return 0xB; } }
+
+		public override int HoldDistance{ get{ return 4; } }
+		public override int TillerManDistance{ get{ return -5; } }
+
+		public override Point2D StarboardOffset{ get{ return new Point2D(  2, 0 ); } }
+		public override Point2D      PortOffset{ get{ return new Point2D( -2, 0 ); } }
+
+		public override Point3D MarkOffset{ get{ return new Point3D( 0, 1, 3 ); } }
+
+		public override BaseDockedBoat DockedBoat{ get{ return new MediumDockedBoat( this ); } }
+
+		[Constructable]
+		public MediumBoat()
+		{
+		}
+
+		public MediumBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+
+	public class MediumBoatDeed : BaseBoatDeed
+	{
+		public override int LabelNumber{ get{ return 1041207; } } // medium ship deed
+		public override BaseBoat Boat{ get{ return new MediumBoat(); } }
+
+		[Constructable]
+		public MediumBoatDeed() : base( 0x8, Point3D.Zero )
+		{
+		}
+
+		public MediumBoatDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+
+	public class MediumDockedBoat : BaseDockedBoat
+	{
+		public override BaseBoat Boat{ get{ return new MediumBoat(); } }
+
+		public MediumDockedBoat( BaseBoat boat ) : base( 0x8, Point3D.Zero, boat )
+		{
+		}
+
+		public MediumDockedBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+}

Scripts/Multis/Boats/MediumDragonBoat.cs

@@ -0,0 +1,103 @@
+using System;
+using Server;
+using Server.Items;
+
+namespace Server.Multis
+{
+	public class MediumDragonBoat : BaseBoat
+	{
+		public override int NorthID{ get{ return 0xC; } }
+		public override int  EastID{ get{ return 0xD; } }
+		public override int SouthID{ get{ return 0xE; } }
+		public override int  WestID{ get{ return 0xF; } }
+
+		public override int HoldDistance{ get{ return 4; } }
+		public override int TillerManDistance{ get{ return -5; } }
+
+		public override Point2D StarboardOffset{ get{ return new Point2D(  2, 0 ); } }
+		public override Point2D      PortOffset{ get{ return new Point2D( -2, 0 ); } }
+
+		public override Point3D MarkOffset{ get{ return new Point3D( 0, 1, 3 ); } }
+
+		public override BaseDockedBoat DockedBoat{ get{ return new MediumDockedDragonBoat( this ); } }
+
+		[Constructable]
+		public MediumDragonBoat()
+		{
+		}
+
+		public MediumDragonBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+
+	public class MediumDragonBoatDeed : BaseBoatDeed
+	{
+		public override int LabelNumber{ get{ return 1041208; } } // medium dragon ship deed
+		public override BaseBoat Boat{ get{ return new MediumDragonBoat(); } }
+
+		[Constructable]
+		public MediumDragonBoatDeed() : base( 0xC, Point3D.Zero )
+		{
+		}
+
+		public MediumDragonBoatDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+
+	public class MediumDockedDragonBoat : BaseDockedBoat
+	{
+		public override BaseBoat Boat{ get{ return new MediumDragonBoat(); } }
+
+		public MediumDockedDragonBoat( BaseBoat boat ) : base( 0xC, Point3D.Zero, boat )
+		{
+		}
+
+		public MediumDockedDragonBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+}

Scripts/Multis/Boats/Plank.cs

@@ -0,0 +1,314 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Factions;
+using Server.Multis;
+
+namespace Server.Items
+{
+	public enum PlankSide{ Port, Starboard }
+
+	public class Plank : Item, ILockable
+	{
+		private BaseBoat m_Boat;
+		private PlankSide m_Side;
+		private bool m_Locked;
+		private uint m_KeyValue;
+
+		private Timer m_CloseTimer;
+
+		public Plank( BaseBoat boat, PlankSide side, uint keyValue ) : base( 0x3EB1 + (int)side )
+		{
+			m_Boat = boat;
+			m_Side = side;
+			m_KeyValue = keyValue;
+			m_Locked = true;
+
+			Movable = false;
+		}
+
+		public Plank( Serial serial ) : base(serial)
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );//version
+
+			writer.Write( m_Boat );
+			writer.Write( (int) m_Side );
+			writer.Write( m_Locked );
+			writer.Write( m_KeyValue );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 0:
+				{
+					m_Boat = reader.ReadItem() as BaseBoat;
+					m_Side = (PlankSide) reader.ReadInt();
+					m_Locked = reader.ReadBool();
+					m_KeyValue = reader.ReadUInt();
+
+					if ( m_Boat == null )
+						Delete();
+
+					break;
+				}
+			}
+
+			if ( IsOpen )
+			{
+				m_CloseTimer = new CloseTimer( this );
+				m_CloseTimer.Start();
+			}
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public BaseBoat Boat{ get{ return m_Boat; } set{ m_Boat = value; } }
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public PlankSide Side{ get{ return m_Side; } set{ m_Side = value; } }
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public bool Locked{ get{ return m_Locked; } set{ m_Locked = value; } }
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public uint KeyValue{ get{ return m_KeyValue; } set{ m_KeyValue = value; } }
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public bool IsOpen{ get{ return ( ItemID == 0x3ED5 || ItemID == 0x3ED4 || ItemID == 0x3E84 || ItemID == 0x3E89 ); } }
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public bool Starboard{ get{ return ( m_Side == PlankSide.Starboard ); } }
+
+		public void SetFacing( Direction dir )
+		{
+			if ( IsOpen )
+			{
+				switch ( dir )
+				{
+					case Direction.North: ItemID = Starboard ? 0x3ED4 : 0x3ED5; break;
+					case Direction.East:  ItemID = Starboard ? 0x3E84 : 0x3E89; break;
+					case Direction.South: ItemID = Starboard ? 0x3ED5 : 0x3ED4; break;
+					case Direction.West:  ItemID = Starboard ? 0x3E89 : 0x3E84; break;
+				}
+			}
+			else
+			{
+				switch ( dir )
+				{
+					case Direction.North: ItemID = Starboard ? 0x3EB2 : 0x3EB1; break;
+					case Direction.East:  ItemID = Starboard ? 0x3E85 : 0x3E8A; break;
+					case Direction.South: ItemID = Starboard ? 0x3EB1 : 0x3EB2; break;
+					case Direction.West:  ItemID = Starboard ? 0x3E8A : 0x3E85; break;
+				}
+			}
+		}
+
+		public void Open()
+		{
+			if ( IsOpen || Deleted )
+				return;
+
+			if ( m_CloseTimer != null )
+				m_CloseTimer.Stop();
+
+			m_CloseTimer = new CloseTimer( this );
+			m_CloseTimer.Start();
+
+			switch ( ItemID )
+			{
+				case 0x3EB1: ItemID = 0x3ED5; break;
+				case 0x3E8A: ItemID = 0x3E89; break;
+				case 0x3EB2: ItemID = 0x3ED4; break;
+				case 0x3E85: ItemID = 0x3E84; break;
+			}
+
+			if ( m_Boat != null )
+				m_Boat.Refresh();
+		}
+
+		public override bool OnMoveOver( Mobile from )
+		{
+			if ( IsOpen )
+			{
+				if ( from is BaseFactionGuard )
+					return false;
+
+				if ( (from.Direction & Direction.Running) != 0 || (m_Boat != null && !m_Boat.Contains( from )) )
+					return true;
+
+				Map map = Map;
+
+				if ( map == null )
+					return false;
+
+				int rx = 0, ry = 0;
+
+				if ( ItemID == 0x3ED4 )
+					rx = 1;
+				else if ( ItemID == 0x3ED5 )
+					rx = -1;
+				else if ( ItemID == 0x3E84 )
+					ry = 1;
+				else if ( ItemID == 0x3E89 )
+					ry = -1;
+
+				for ( int i = 1; i <= 6; ++i )
+				{
+					int x = X + (i*rx);
+					int y = Y + (i*ry);
+					int z;
+
+					for ( int j = -8; j <= 8; ++j )
+					{
+						z = from.Z + j;
+
+						if ( map.CanFit( x, y, z, 16, false, false ) && !Server.Spells.SpellHelper.CheckMulti( new Point3D( x, y, z ), map ) && !Region.Find( new Point3D( x, y, z ), map ).IsPartOf( typeof( Factions.StrongholdRegion ) ) )
+						{
+							if ( i == 1 && j >= -2 && j <= 2 )
+								return true;
+
+							from.Location = new Point3D( x, y, z );
+							return false;
+						}
+					}
+
+					z = map.GetAverageZ( x, y );
+
+					if ( map.CanFit( x, y, z, 16, false, false ) && !Server.Spells.SpellHelper.CheckMulti( new Point3D( x, y, z ), map ) && !Region.Find( new Point3D( x, y, z ), map ).IsPartOf( typeof( Factions.StrongholdRegion ) ) )
+					{
+						if ( i == 1 )
+							return true;
+
+						from.Location = new Point3D( x, y, z );
+						return false;
+					}
+				}
+
+				return true;
+			}
+			else
+			{
+				return false;
+			}
+		}
+
+		public bool CanClose()
+		{
+			Map map = Map;
+
+			if ( map == null || Deleted )
+				return false;
+
+			foreach ( object o in this.GetObjectsInRange( 0 ) )
+			{
+				if ( o != this )
+					return false;
+			}
+
+			return true;
+		}
+
+		public void Close()
+		{
+			if ( !IsOpen || !CanClose() || Deleted )
+				return;
+
+			if ( m_CloseTimer != null )
+				m_CloseTimer.Stop();
+
+			m_CloseTimer = null;
+
+			switch ( ItemID )
+			{
+				case 0x3ED5: ItemID = 0x3EB1; break;
+				case 0x3E89: ItemID = 0x3E8A; break;
+				case 0x3ED4: ItemID = 0x3EB2; break;
+				case 0x3E84: ItemID = 0x3E85; break;
+			}
+
+			if ( m_Boat != null )
+				m_Boat.Refresh();
+		}
+
+		public override void OnDoubleClickDead( Mobile from )
+		{
+			OnDoubleClick( from );
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( m_Boat == null )
+				return;
+
+			if ( from.InRange( GetWorldLocation(), 8 ) )
+			{
+				if ( m_Boat.Contains( from ) )
+				{
+					if ( IsOpen )
+						Close();
+					else
+						Open();
+				}
+				else
+				{
+					if ( !IsOpen )
+					{
+						if ( !Locked )
+						{
+							Open();
+						}
+						else if ( from.AccessLevel >= AccessLevel.GameMaster )
+						{
+							from.LocalOverheadMessage( Network.MessageType.Regular, 0x00, 502502 ); // That is locked but your godly powers allow access
+							Open();
+						}
+						else
+						{
+							from.LocalOverheadMessage( Network.MessageType.Regular, 0x00, 502503 ); // That is locked.
+						}
+					}
+					else if ( !Locked )
+					{
+						from.Location = new Point3D( this.X, this.Y, this.Z + 3 );
+					}
+					else if ( from.AccessLevel >= AccessLevel.GameMaster )
+					{
+						from.LocalOverheadMessage( Network.MessageType.Regular, 0x00, 502502 ); // That is locked but your godly powers allow access
+						from.Location = new Point3D( this.X, this.Y, this.Z + 3 );
+					}
+					else
+					{
+						from.LocalOverheadMessage( Network.MessageType.Regular, 0x00, 502503 ); // That is locked.
+					}
+				}
+			}
+		}
+
+		private class CloseTimer : Timer
+		{
+			private Plank m_Plank;
+
+			public CloseTimer( Plank plank ) : base( TimeSpan.FromSeconds( 5.0 ), TimeSpan.FromSeconds( 5.0 ) )
+			{
+				m_Plank = plank;
+				Priority = TimerPriority.OneSecond;
+			}
+
+			protected override void OnTick()
+			{
+				m_Plank.Close();
+			}
+		}
+	}
+}

Scripts/Multis/Boats/RenameBoatPrompt.cs

@@ -0,0 +1,21 @@
+using System;
+using Server;
+using Server.Prompts;
+
+namespace Server.Multis
+{
+	public class RenameBoatPrompt : Prompt
+	{
+		private BaseBoat m_Boat;
+
+		public RenameBoatPrompt( BaseBoat boat )
+		{
+			m_Boat = boat;
+		}
+
+		public override void OnResponse( Mobile from, string text )
+		{
+			m_Boat.EndRename( from, text );
+		}
+	}
+}

Scripts/Multis/Boats/SmallBoat.cs

@@ -0,0 +1,103 @@
+using System;
+using Server;
+using Server.Items;
+
+namespace Server.Multis
+{
+	public class SmallBoat : BaseBoat
+	{
+		public override int NorthID{ get{ return 0x0; } }
+		public override int  EastID{ get{ return 0x1; } }
+		public override int SouthID{ get{ return 0x2; } }
+		public override int  WestID{ get{ return 0x3; } }
+
+		public override int HoldDistance{ get{ return 4; } }
+		public override int TillerManDistance{ get{ return -4; } }
+
+		public override Point2D StarboardOffset{ get{ return new Point2D(  2, 0 ); } }
+		public override Point2D      PortOffset{ get{ return new Point2D( -2, 0 ); } }
+
+		public override Point3D MarkOffset{ get{ return new Point3D( 0, 1, 3 ); } }
+
+		public override BaseDockedBoat DockedBoat{ get{ return new SmallDockedBoat( this ); } }
+
+		[Constructable]
+		public SmallBoat()
+		{
+		}
+
+		public SmallBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+
+	public class SmallBoatDeed : BaseBoatDeed
+	{
+		public override int LabelNumber{ get{ return 1041205; } } // small ship deed
+		public override BaseBoat Boat{ get{ return new SmallBoat(); } }
+
+		[Constructable]
+		public SmallBoatDeed() : base( 0x0, Point3D.Zero )
+		{
+		}
+
+		public SmallBoatDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+
+	public class SmallDockedBoat : BaseDockedBoat
+	{
+		public override BaseBoat Boat{ get{ return new SmallBoat(); } }
+
+		public SmallDockedBoat( BaseBoat boat ) : base( 0x0, Point3D.Zero, boat )
+		{
+		}
+
+		public SmallDockedBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+}

Scripts/Multis/Boats/SmallDragonBoat.cs

@@ -0,0 +1,103 @@
+using System;
+using Server;
+using Server.Items;
+
+namespace Server.Multis
+{
+	public class SmallDragonBoat : BaseBoat
+	{
+		public override int NorthID{ get{ return 0x4; } }
+		public override int  EastID{ get{ return 0x5; } }
+		public override int SouthID{ get{ return 0x6; } }
+		public override int  WestID{ get{ return 0x7; } }
+
+		public override int HoldDistance{ get{ return 4; } }
+		public override int TillerManDistance{ get{ return -4; } }
+
+		public override Point2D StarboardOffset{ get{ return new Point2D(  2, 0 ); } }
+		public override Point2D      PortOffset{ get{ return new Point2D( -2, 0 ); } }
+
+		public override Point3D MarkOffset{ get{ return new Point3D( 0, 1, 3 ); } }
+
+		public override BaseDockedBoat DockedBoat{ get{ return new SmallDockedDragonBoat( this ); } }
+
+		[Constructable]
+		public SmallDragonBoat()
+		{
+		}
+
+		public SmallDragonBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+
+	public class SmallDragonBoatDeed : BaseBoatDeed
+	{
+		public override int LabelNumber{ get{ return 1041206; } } // small dragon ship deed
+		public override BaseBoat Boat{ get{ return new SmallDragonBoat(); } }
+
+		[Constructable]
+		public SmallDragonBoatDeed() : base( 0x4, Point3D.Zero )
+		{
+		}
+
+		public SmallDragonBoatDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+
+	public class SmallDockedDragonBoat : BaseDockedBoat
+	{
+		public override BaseBoat Boat{ get{ return new SmallDragonBoat(); } }
+
+		public SmallDockedDragonBoat( BaseBoat boat ) : base( 0x4, Point3D.Zero, boat )
+		{
+		}
+
+		public SmallDockedDragonBoat( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int)0 );
+		}
+	}
+}

Scripts/Multis/Boats/Strandedness.cs

@@ -0,0 +1,188 @@
+using System;
+using System.IO;
+using Server;
+
+namespace Server.Misc
+{
+	public class Strandedness
+	{
+		private static Point2D[] m_Felucca = new Point2D[]
+			{
+				new Point2D( 2528, 3568 ), new Point2D( 2376, 3400 ), new Point2D( 2528, 3896 ),
+				new Point2D( 2168, 3904 ), new Point2D( 1136, 3416 ), new Point2D( 1432, 3648 ),
+				new Point2D( 1416, 4000 ), new Point2D( 4512, 3936 ), new Point2D( 4440, 3120 ),
+				new Point2D( 4192, 3672 ), new Point2D( 4720, 3472 ), new Point2D( 3744, 2768 ),
+				new Point2D( 3480, 2432 ), new Point2D( 3560, 2136 ), new Point2D( 3792, 2112 ),
+				new Point2D( 2800, 2296 ), new Point2D( 2736, 2016 ), new Point2D( 4576, 1456 ),
+				new Point2D( 4680, 1152 ), new Point2D( 4304, 1104 ), new Point2D( 4496, 984 ),
+				new Point2D( 4248, 696 ), new Point2D( 4040, 616 ), new Point2D( 3896, 248 ),
+				new Point2D( 4176, 384 ), new Point2D( 3672, 1104 ), new Point2D( 3520, 1152 ),
+				new Point2D( 3720, 1360 ), new Point2D( 2184, 2152 ), new Point2D( 1952, 2088 ),
+				new Point2D( 2056, 1936 ), new Point2D( 1720, 1992 ), new Point2D( 472, 2064 ),
+				new Point2D( 656, 2096 ), new Point2D( 3008, 3592 ), new Point2D( 2784, 3472 ),
+				new Point2D( 5456, 2400 ), new Point2D( 5976, 2424 ), new Point2D( 5328, 3112 ),
+				new Point2D( 5792, 3152 ), new Point2D( 2120, 3616 ), new Point2D( 2136, 3128 ),
+				new Point2D( 1632, 3528 ), new Point2D( 1328, 3160 ), new Point2D( 1072, 3136 ),
+				new Point2D( 1128, 2976 ), new Point2D( 960, 2576 ), new Point2D( 752, 1832 ),
+				new Point2D( 184, 1488 ), new Point2D( 592, 1440 ), new Point2D( 368, 1216 ),
+				new Point2D( 232, 752 ), new Point2D( 696, 744 ), new Point2D( 304, 1000 ),
+				new Point2D( 840, 376 ), new Point2D( 1192, 624 ), new Point2D( 1200, 192 ),
+				new Point2D( 1512, 240 ), new Point2D( 1336, 456 ), new Point2D( 1536, 648 ),
+				new Point2D( 1104, 952 ), new Point2D( 1864, 264 ), new Point2D( 2136, 200 ),
+				new Point2D( 2160, 528 ), new Point2D( 1904, 512 ), new Point2D( 2240, 784 ),
+				new Point2D( 2536, 776 ), new Point2D( 2488, 216 ), new Point2D( 2336, 72 ),
+				new Point2D( 2648, 288 ), new Point2D( 2680, 576 ), new Point2D( 2896, 88 ),
+				new Point2D( 2840, 344 ), new Point2D( 3136, 72 ), new Point2D( 2968, 520 ),
+				new Point2D( 3192, 328 ), new Point2D( 3448, 208 ), new Point2D( 3432, 608 ),
+				new Point2D( 3184, 752 ), new Point2D( 2800, 704 ), new Point2D( 2768, 1016 ),
+				new Point2D( 2448, 1232 ), new Point2D( 2272, 920 ), new Point2D( 2072, 1080 ),
+				new Point2D( 2048, 1264 ), new Point2D( 1808, 1528 ), new Point2D( 1496, 1880 ),
+				new Point2D( 1656, 2168 ), new Point2D( 2096, 2320 ), new Point2D( 1816, 2528 ),
+				new Point2D( 1840, 2640 ), new Point2D( 1928, 2952 ), new Point2D( 2120, 2712 )
+			};
+
+		private static Point2D[] m_Trammel = m_Felucca;
+
+		private static Point2D[] m_Ilshenar = new Point2D[]
+			{
+				new Point2D( 1252, 1180 ), new Point2D( 1562, 1090 ), new Point2D( 1444, 1016 ),
+				new Point2D( 1324, 968 ), new Point2D( 1418, 806 ), new Point2D( 1722, 874 ),
+				new Point2D( 1456, 684 ), new Point2D( 1036, 866 ), new Point2D( 612, 476 ),
+				new Point2D( 1476, 372 ), new Point2D( 762, 472 ), new Point2D( 812, 1162 ),
+				new Point2D( 1422, 1144 ), new Point2D( 1254, 1066 ), new Point2D( 1598, 870 ),
+				new Point2D( 1358, 866 ), new Point2D( 510, 302 ), new Point2D( 510, 392 )
+			};
+
+		private static Point2D[] m_Tokuno = new Point2D[]
+			{
+				//Makoto-Jima
+				new Point2D( 837, 1351 ), new Point2D( 941, 1241 ), new Point2D( 959, 1185 ),
+				new Point2D( 923, 1091 ), new Point2D( 904, 983 ), new Point2D( 845, 944 ),
+				new Point2D( 829, 896 ), new Point2D( 794, 852 ), new Point2D( 766, 821 ),
+				new Point2D( 695, 814 ), new Point2D( 576, 835 ), new Point2D( 518, 840 ),
+				new Point2D( 519, 902 ), new Point2D( 502, 950 ), new Point2D( 503, 1045 ),
+				new Point2D( 547, 1131 ), new Point2D( 518, 1204 ), new Point2D( 506, 1243 ),
+				new Point2D( 526, 1271 ), new Point2D( 562, 1295 ), new Point2D( 616, 1335 ),
+				new Point2D( 789, 1347 ), new Point2D( 712, 1359 ),
+
+				//Homare-Jima
+				new Point2D( 202, 498 ), new Point2D( 116, 600 ), new Point2D( 107, 699 ),
+				new Point2D( 162, 799 ), new Point2D( 158, 889 ), new Point2D( 169, 989 ),
+				new Point2D( 194, 1101 ), new Point2D( 250, 1163 ), new Point2D( 295, 1176 ),
+				new Point2D( 280, 1194 ), new Point2D( 286, 1102 ), new Point2D( 250, 1000 ),
+				new Point2D( 260, 906 ), new Point2D( 360, 838 ), new Point2D( 389, 763 ),
+				new Point2D( 415, 662 ), new Point2D( 500, 597 ), new Point2D( 570, 572 ),
+				new Point2D( 631, 577 ), new Point2D( 692, 500 ), new Point2D( 723, 445 ),
+				new Point2D( 672, 379 ), new Point2D( 626, 332 ), new Point2D( 494, 291 ),
+				new Point2D( 371, 336 ), new Point2D( 324, 334 ), new Point2D( 270, 362 ),
+
+				//Isamu-Jima
+				new Point2D( 1240, 1076 ), new Point2D( 1189, 1115 ), new Point2D( 1046, 1039 ),
+				new Point2D( 1025, 885 ), new Point2D( 907, 809 ), new Point2D( 840, 506 ),
+				new Point2D( 799, 396 ), new Point2D( 720, 258 ), new Point2D( 744, 158 ),
+				new Point2D( 904, 37 ), new Point2D( 974, 91 ), new Point2D( 1020, 187 ),
+				new Point2D( 1035, 288 ), new Point2D( 1104, 395 ), new Point2D( 1215, 462 ),
+				new Point2D( 1275, 488 ), new Point2D( 1348, 611 ), new Point2D( 1363, 739 ),
+				new Point2D( 1364, 765 ), new Point2D( 1364, 876 ), new Point2D( 1300, 936 ),
+				new Point2D( 1240, 1003 )
+
+
+			};
+
+		public static void Initialize()
+		{
+			EventSink.Login += new LoginEventHandler( EventSink_Login );
+		}
+
+		private static bool IsStranded( Mobile from )
+		{
+			Map map = from.Map;
+
+			if ( map == null )
+				return false;
+			
+			if ( map == Map.Felucca || map == Map.Trammel )
+				if ( from.X >= 5189 && from.Y >= 696 && from.X <= 5192 && from.Y <= 698 )
+					return false;
+
+			object surface = map.GetTopSurface( from.Location );
+
+			if ( surface is LandTile ) {
+				int id = ((LandTile)surface).ID;
+
+				return (id >= 168 && id <= 171)
+					|| (id >= 310 && id <= 311);
+			} else if ( surface is StaticTile ) {
+				int id = ((StaticTile)surface).ID;
+
+				return (id >= 0x1796 && id <= 0x17B2);
+			}
+
+			return false;
+		}
+
+		public static void EventSink_Login( LoginEventArgs e )
+		{
+			Mobile from = e.Mobile;
+
+			if ( !IsStranded( from ) )
+				return;
+
+			Map map = from.Map;
+
+			Point2D[] list;
+
+			if( map == Map.Felucca )
+				list = m_Felucca;
+			else if( map == Map.Trammel )
+				list = m_Trammel;
+			else if( map == Map.Ilshenar )
+				list = m_Ilshenar;
+			else if( map == Map.Tokuno )
+				list = m_Tokuno;
+			else
+				return;
+
+			Point2D p = Point2D.Zero;
+			double pdist = double.MaxValue;
+
+			for ( int i = 0; i < list.Length; ++i )
+			{
+				double dist = from.GetDistanceToSqrt( list[i] );
+
+				if ( dist < pdist )
+				{
+					p = list[i];
+					pdist = dist;
+				}
+			}
+
+			int x = p.X, y = p.Y;
+			int z;
+			bool canFit = false;
+
+			z = map.GetAverageZ( x, y );
+			canFit = map.CanSpawnMobile( x, y, z );
+
+			for ( int i = 1; !canFit && i <= 40; i += 2 )
+			{
+				for ( int xo = -1; !canFit && xo <= 1; ++xo )
+				{
+					for ( int yo = -1; !canFit && yo <= 1; ++yo )
+					{
+						if ( xo == 0 && yo == 0 )
+							continue;
+
+						x = p.X + (xo * i);
+						y = p.Y + (yo * i);
+						z = map.GetAverageZ( x, y );
+						canFit = map.CanSpawnMobile( x, y, z );
+					}
+				}
+			}
+
+			if ( canFit )
+				from.Location = new Point3D( x, y, z );
+		}
+	}
+}

Scripts/Multis/Boats/TillerMan.cs

@@ -0,0 +1,119 @@
+using System;
+using Server;
+using Server.Multis;
+using Server.Network;
+
+namespace Server.Items
+{
+	public class TillerMan : Item
+	{
+		private BaseBoat m_Boat;
+
+		public TillerMan( BaseBoat boat ) : base( 0x3E4E )
+		{
+			m_Boat = boat;
+			Movable = false;
+		}
+
+		public TillerMan( Serial serial ) : base(serial)
+		{
+		}
+
+		public void SetFacing( Direction dir )
+		{
+			switch ( dir )
+			{
+				case Direction.South: ItemID = 0x3E4B; break;
+				case Direction.North: ItemID = 0x3E4E; break;
+				case Direction.West:  ItemID = 0x3E50; break;
+				case Direction.East:  ItemID = 0x3E55; break;
+			}
+		}
+
+		public override void GetProperties( ObjectPropertyList list )
+		{
+			base.GetProperties( list );
+
+			list.Add( m_Boat.Status );
+		}
+
+		public void Say( int number )
+		{
+			PublicOverheadMessage( MessageType.Regular, 0x3B2, number );
+		}
+
+		public void Say( int number, string args )
+		{
+			PublicOverheadMessage( MessageType.Regular, 0x3B2, number, args );
+		}
+
+		public override void AddNameProperty( ObjectPropertyList list )
+		{
+			if ( m_Boat != null && m_Boat.ShipName != null )
+				list.Add( 1042884, m_Boat.ShipName ); // the tiller man of the ~1_SHIP_NAME~
+			else
+				base.AddNameProperty( list );
+		}
+
+		public override void OnSingleClick( Mobile from )
+		{
+			if ( m_Boat != null && m_Boat.ShipName != null )
+				LabelTo( from, 1042884, m_Boat.ShipName ); // the tiller man of the ~1_SHIP_NAME~
+			else
+				base.OnSingleClick( from );
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( m_Boat != null && m_Boat.Contains( from ) )
+				m_Boat.BeginRename( from );
+			else if ( m_Boat != null )
+				m_Boat.BeginDryDock( from );
+		}
+
+		public override bool OnDragDrop( Mobile from, Item dropped )
+		{
+			if ( dropped is MapItem && m_Boat != null && m_Boat.CanCommand( from ) && m_Boat.Contains( from ) )
+			{
+				m_Boat.AssociateMap( (MapItem) dropped );
+			}
+
+			return false;
+		}
+
+		public override void OnAfterDelete()
+		{
+			if ( m_Boat != null )
+				m_Boat.Delete();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );//version
+
+			writer.Write( m_Boat );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 0:
+				{
+					m_Boat = reader.ReadItem() as BaseBoat;
+
+					if ( m_Boat == null )
+						Delete();
+
+					break;
+				}
+			}
+		}
+	}
+}

Scripts/Multis/Camps/BankerCamp.cs

@@ -0,0 +1,49 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Mobiles;
+
+namespace Server.Multis
+{
+	public class BankerCamp : BaseCamp
+	{
+		[Constructable]
+		public BankerCamp() : base( 0x1F6 )
+		{
+		}
+
+		public override void AddComponents()
+		{
+			BaseDoor west, east;
+
+			AddItem( west = new LightWoodGate( DoorFacing.WestCW ), -4, 4, 7 );
+			AddItem( east = new LightWoodGate( DoorFacing.EastCCW ), -3, 4, 7 );
+
+			west.Link = east;
+			east.Link = west;
+
+			AddItem( new Sign( SignType.Bank, SignFacing.West ), -5, 5, -4 );
+
+			AddMobile( new Banker(), 4, -4,  3, 7 );
+			AddMobile( new Banker(), 5,  4, -2, 0 );
+		}
+
+		public BankerCamp( 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/Multis/Camps/BaseCamp.cs

@@ -0,0 +1,207 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Items;
+using Server.Mobiles;
+using System.Collections.Generic;
+
+namespace Server.Multis
+{
+	public abstract class BaseCamp : BaseMulti
+	{
+		private List<Item> m_Items;
+		private List<Mobile> m_Mobiles;
+		private DateTime m_DecayTime;
+		private Timer m_DecayTimer;
+		private TimeSpan m_DecayDelay;
+
+		public virtual int EventRange{ get{ return 10; } }
+
+		public virtual TimeSpan DecayDelay
+		{
+			get
+			{
+				return m_DecayDelay;
+			} 
+			set
+			{
+				m_DecayDelay = value;
+				RefreshDecay( true );
+			} 
+		}
+
+		public BaseCamp( int multiID ) : base( multiID )
+		{
+			m_Items = new List<Item>();
+			m_Mobiles = new List<Mobile>();
+			m_DecayDelay = TimeSpan.FromMinutes( 30.0 );
+			RefreshDecay( true );
+
+			Timer.DelayCall( TimeSpan.Zero, new TimerCallback( CheckAddComponents ) );
+		}
+
+		public void CheckAddComponents()
+		{
+			if ( Deleted )
+				return;
+			
+			AddComponents();
+		}
+
+		public virtual void AddComponents()
+		{
+		}
+
+		public virtual void RefreshDecay( bool setDecayTime )
+		{
+			if ( Deleted )
+				return;
+
+			if ( m_DecayTimer != null )
+				m_DecayTimer.Stop();
+
+			if ( setDecayTime )
+				m_DecayTime = DateTime.UtcNow + DecayDelay;
+
+			m_DecayTimer = Timer.DelayCall( DecayDelay, new TimerCallback( Delete ) );
+		}
+
+		public virtual void AddItem( Item item, int xOffset, int yOffset, int zOffset )
+		{
+			m_Items.Add( item );
+
+			int zavg = Map.GetAverageZ(X + xOffset, Y + yOffset);
+			item.MoveToWorld( new Point3D( X + xOffset, Y + yOffset, zavg + zOffset ), Map );
+		}
+
+		public virtual void AddMobile( Mobile m, int wanderRange, int xOffset, int yOffset, int zOffset )
+		{
+			m_Mobiles.Add(m);
+
+			int zavg = Map.GetAverageZ(X + xOffset, Y + yOffset);
+			Point3D loc = new Point3D(X + xOffset, Y + yOffset, zavg + zOffset);
+			BaseCreature bc = m as BaseCreature;
+
+			if ( bc != null )
+			{
+				bc.RangeHome = wanderRange; 
+				bc.Home = loc; 
+			}
+
+			if ( m is BaseVendor || m is Banker )
+				m.Direction = Direction.South;
+
+			m.MoveToWorld( loc, this.Map );
+		}
+
+		public virtual void OnEnter( Mobile m )
+		{
+			RefreshDecay( true );
+		}
+
+		public virtual void OnExit( Mobile m )
+		{
+			RefreshDecay( true );
+		}
+
+		public override bool HandlesOnMovement{ get{ return true; } }
+
+		public override void OnMovement( Mobile m, Point3D oldLocation )
+		{
+			bool inOldRange = Utility.InRange( oldLocation, Location, EventRange );
+			bool inNewRange = Utility.InRange( m.Location, Location, EventRange );
+
+			if ( inNewRange && !inOldRange )
+				OnEnter( m );
+			else if ( inOldRange && !inNewRange )
+				OnExit( m );
+		}
+
+		public override void OnAfterDelete()
+		{
+			base.OnAfterDelete();
+
+			for ( int i = 0; i < m_Items.Count; ++i )
+				m_Items[i].Delete();
+
+			for ( int i = 0; i < m_Mobiles.Count; ++i )
+			{
+				BaseCreature bc = (BaseCreature)m_Mobiles[i];
+
+				if ( bc.IsPrisoner == false )
+					m_Mobiles[i].Delete();
+				else if ( m_Mobiles[i].CantWalk == true )
+					m_Mobiles[i].Delete();
+			}
+
+			m_Items.Clear();
+			m_Mobiles.Clear();
+		}
+
+		public BaseCamp( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+
+			writer.Write( m_Items, true );
+			writer.Write( m_Mobiles, true );
+			writer.WriteDeltaTime( m_DecayTime );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 0:
+				{
+					m_Items = reader.ReadStrongItemList();
+					m_Mobiles = reader.ReadStrongMobileList();
+					m_DecayTime = reader.ReadDeltaTime();
+
+					RefreshDecay( false );
+
+					break;
+				}
+			}
+		}
+	}
+
+	public class LockableBarrel : LockableContainer
+	{
+		[Constructable]
+		public LockableBarrel() : base(0xE77)
+		{
+			Weight = 1.0;
+		}
+
+		public LockableBarrel(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();
+
+			if (Weight == 8.0)
+				Weight = 1.0;
+		}
+	}
+}

Scripts/Multis/Camps/BrigandCamp.cs

@@ -0,0 +1,194 @@
+using System;
+using Server.Items;
+using Server.Mobiles;
+
+namespace Server.Multis
+{	
+	public class BrigandCamp : BaseCamp
+	{
+		public virtual Mobile Brigands{ get{ return new Brigand(); } }
+		public virtual Mobile Executioners{ get{ return new Executioner(); } }
+		
+		private Mobile m_Prisoner;
+		
+		[Constructable]
+		public BrigandCamp() : base( 0x10EE ) // dummy garbage at center
+		{
+		}
+
+		public override void AddComponents()
+		{
+			BaseCreature bc;
+			//BaseEscortable be;
+
+			Visible = false;
+			DecayDelay = TimeSpan.FromMinutes( 5.0 );
+
+			AddItem(new Static(0x10ee), 0, 0, 0);
+			AddItem(new Static(0xfac), 0, 7, 0);
+			
+			switch ( Utility.Random( 3 ) )
+			{
+				case 0:
+				{
+					AddItem( new Item( 0xDE3 ), 0, 7, 0 ); // Campfire
+					AddItem( new Item( 0x974 ), 0, 7, 1 ); // Cauldron
+					break;
+				}
+				case 1:
+				{
+					AddItem( new Item( 0x1E95 ), 0, 7, 1 ); // Rabbit on a spit
+					break;
+				}
+				default:
+				{
+					AddItem( new Item( 0x1E94 ), 0, 7, 1 ); // Chicken on a spit
+					break;
+				}
+			}
+
+			AddCampChests();
+			
+			for ( int i = 0; i < 4; i ++ )
+			{				
+				AddMobile( Brigands, 6, Utility.RandomMinMax( -7, 7 ), Utility.RandomMinMax( -7, 7 ), 0 );
+			}
+			
+			switch ( Utility.Random( 2 ) )
+			{
+				case 0: m_Prisoner = new Noble(); break;
+				default: m_Prisoner = new SeekerOfAdventure(); break;
+			}
+			
+			//be = (BaseEscortable)m_Prisoner;
+			//be.m_Captive = true;
+			
+			bc = (BaseCreature)m_Prisoner;
+			bc.IsPrisoner = true;
+			bc.CantWalk = true;
+			
+			m_Prisoner.YellHue = Utility.RandomList( 0x57, 0x67, 0x77, 0x87, 0x117 );
+			AddMobile( m_Prisoner, 2, Utility.RandomMinMax( -2, 2 ), Utility.RandomMinMax( -2, 2 ), 0 );
+		}
+
+		private void AddCampChests()
+		{
+			LockableContainer chest = null;
+
+			switch (Utility.Random(3))
+			{
+				case 0: chest = new MetalChest(); break;
+				case 1: chest = new MetalGoldenChest(); break;
+				default: chest = new WoodenChest(); break;
+			}
+
+			chest.LiftOverride = true;
+
+			TreasureMapChest.Fill(chest, 1);
+
+			AddItem(chest, -2, -2, 0);
+
+			LockableContainer crates = null;
+
+			switch (Utility.Random(4))
+			{
+				case 0: crates = new SmallCrate(); break;
+				case 1: crates = new MediumCrate(); break;
+				case 2: crates = new LargeCrate(); break;
+				default: crates = new LockableBarrel(); break;
+			}
+
+			crates.TrapType = TrapType.ExplosionTrap;
+			crates.TrapPower = Utility.RandomMinMax(30, 40);
+			crates.TrapLevel = 2;
+
+			crates.RequiredSkill = 76;
+			crates.LockLevel = 66;
+			crates.MaxLockLevel = 116;
+			crates.Locked = true;
+
+			crates.DropItem(new Gold(Utility.RandomMinMax(100, 400)));
+			crates.DropItem(new Arrow(10));
+			crates.DropItem(new Bolt(10));
+
+			crates.LiftOverride = true;
+
+			if (Utility.RandomDouble() < 0.8)
+			{
+				switch (Utility.Random(4))
+				{
+					case 0: crates.DropItem(new LesserCurePotion()); break;
+					case 1: crates.DropItem(new LesserExplosionPotion()); break;
+					case 2: crates.DropItem(new LesserHealPotion()); break;
+					default: crates.DropItem(new LesserPoisonPotion()); break;
+				}
+			}
+
+			AddItem(crates, 2, 2, 0);
+		}
+
+		// Don't refresh decay timer
+		public override void OnEnter( Mobile m )
+		{
+			if ( m.Player && m_Prisoner != null && m_Prisoner.CantWalk )
+			{
+				int number;
+
+				switch ( Utility.Random( 8 ) )
+				{
+					case 0: number = 502261; break; // HELP!
+					case 1: number = 502262; break; // Help me!
+					case 2: number = 502263; break; // Canst thou aid me?!
+					case 3: number = 502264; break; // Help a poor prisoner!
+					case 4: number = 502265; break; // Help! Please!
+					case 5: number = 502266; break; // Aaah! Help me!
+					case 6: number = 502267; break; // Go and get some help!
+					default: number = 502268; break; // Quickly, I beg thee! Unlock my chains! If thou dost look at me close thou canst see them.	
+				}
+				m_Prisoner.Yell( number );
+			}
+		}
+
+		// Don't refresh decay timer
+		public override void OnExit(Mobile m)
+		{
+		}
+
+		public BrigandCamp( Serial serial ) : base( serial )
+		{
+		}
+		
+		public override void AddItem( Item item, int xOffset, int yOffset, int zOffset )
+		{
+			if ( item != null )
+				item.Movable = false;
+				
+			base.AddItem( item, xOffset, yOffset, zOffset );
+		}
+			
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+
+			writer.Write( m_Prisoner );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 0:
+				{
+					m_Prisoner = reader.ReadMobile();
+					break;
+				}
+			}
+		}
+	}
+}

Scripts/Multis/Camps/HealerCamp.cs

@@ -0,0 +1,49 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Mobiles;
+
+namespace Server.Multis
+{
+	public class HealerCamp : BaseCamp
+	{
+		[Constructable]
+		public HealerCamp() : base( 0x1F4 )
+		{
+		}
+
+		public override void AddComponents()
+		{
+			BaseDoor west, east;
+
+			AddItem( west = new LightWoodGate( DoorFacing.WestCW ), -4, 4, 7 );
+			AddItem( east = new LightWoodGate( DoorFacing.EastCCW ), -3, 4, 7 );
+
+			west.Link = east;
+			east.Link = west;
+
+			AddItem( new Sign( SignType.Healer, SignFacing.West ), -5, 5, -4 );
+
+			AddMobile( new Healer(), 4, -4,  3, 7 );
+			AddMobile( new Healer(), 5,  4, -2, 0 );
+		}
+
+		public HealerCamp( 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/Multis/Camps/LizardmenCamp.cs

@@ -0,0 +1,193 @@
+using System;
+using Server.Items;
+using Server.Mobiles;
+
+namespace Server.Multis
+{   
+	public class LizardmenCamp : BaseCamp
+	{
+		public virtual Mobile Lizardmen{ get{ return new Lizardman(); } }
+		
+		private Mobile m_Prisoner;
+		
+		[Constructable]
+		public LizardmenCamp() : base( 0x10EE ) // dummy garbage at center
+		{
+		}
+
+		public override void AddComponents()
+		{
+			BaseCreature bc;
+			//BaseEscortable be;
+
+			Visible = false;
+			DecayDelay = TimeSpan.FromMinutes( 5.0 );
+			AddItem(new Static(0x10ee), 0, 0, 0);
+			AddItem(new Static(0xfac), 0, 7, 0);
+
+			switch ( Utility.Random( 3 ) )
+			{
+				case 0:
+				{
+					AddItem( new Item( 0xDE3 ), 0, 7, 0 ); // Campfire
+					AddItem( new Item( 0x974 ), 0, 7, 1); // Cauldron
+					break;
+				}
+				case 1:
+				{
+					AddItem( new Item( 0x1E95 ), 0, 7, 1); // Rabbit on a spit
+					break;
+				}
+				default:
+				{
+					AddItem( new Item( 0x1E94 ), 0, 7, 1); // Chicken on a spit
+					break;
+				}
+			}
+			AddItem(new Item(0x41F), 4, 4, 0); // Gruesome Standart South
+
+			AddCampChests();
+
+			for ( int i = 0; i < 4; i ++ )
+			{				
+				AddMobile( Lizardmen, 6, Utility.RandomMinMax( -7, 7 ), Utility.RandomMinMax( -7, 7 ), 0 );
+			}
+			
+			switch ( Utility.Random( 2 ) )
+			{
+				case 0: m_Prisoner = new Noble(); break;
+				default: m_Prisoner = new SeekerOfAdventure(); break;
+			}
+			
+			//be = (BaseEscortable)m_Prisoner;
+			//be.m_Captive = true;
+			
+			bc = (BaseCreature)m_Prisoner;
+			bc.IsPrisoner = true;
+			bc.CantWalk = true;
+			
+			m_Prisoner.YellHue = Utility.RandomList( 0x57, 0x67, 0x77, 0x87, 0x117 );
+			AddMobile( m_Prisoner, 2, Utility.RandomMinMax( -2, 2 ), Utility.RandomMinMax( -2, 2 ), 0 );
+		}
+
+		private void AddCampChests()
+		{
+   			LockableContainer chest = null;
+			
+			switch ( Utility.Random( 3 ) )
+			{
+				case 0: chest = new MetalChest(); break;
+				case 1: chest = new MetalGoldenChest(); break;
+				default: chest = new WoodenChest(); break;
+			}
+
+			chest.LiftOverride = true;
+
+			TreasureMapChest.Fill( chest, 1 );
+						
+			AddItem( chest, 2, -2, 0 );
+			
+			LockableContainer crates = null;
+
+			switch ( Utility.Random( 4 ) )
+			{
+				case 0: crates = new SmallCrate(); break;
+				case 1: crates = new MediumCrate(); break;
+				case 2: crates = new LargeCrate(); break;
+				default: crates = new LockableBarrel(); break;
+			}
+			
+			crates.TrapType = TrapType.ExplosionTrap;
+			crates.TrapPower = Utility.RandomMinMax( 30, 40 );
+			crates.TrapLevel = 2;
+			
+			crates.RequiredSkill = 76;
+			crates.LockLevel = 66;
+			crates.MaxLockLevel = 116;
+			crates.Locked = true;
+			
+			crates.DropItem( new Gold( Utility.RandomMinMax( 100, 400 ) ) );
+			crates.DropItem( new Arrow( 10 ) );
+			crates.DropItem( new Bolt( 10 ) );
+
+			crates.LiftOverride = true;
+			
+			if ( Utility.RandomDouble() < 0.8 )
+			{
+				switch ( Utility.Random( 4 ) )
+				{
+					case 0: crates.DropItem( new LesserCurePotion() ); break;
+					case 1: crates.DropItem( new LesserExplosionPotion() ); break;
+					case 2: crates.DropItem( new LesserHealPotion() ); break;
+					default: crates.DropItem(new LesserPoisonPotion()); break;
+				}
+			}
+			
+			AddItem( crates, -2, 2, 0 );
+		}
+
+		// Don't refresh decay timer
+		public override void OnEnter(Mobile m)
+		{
+			if ( m.Player && m_Prisoner != null && m_Prisoner.CantWalk )
+			{
+				int number;
+
+				switch ( Utility.Random( 8 ) )
+				{
+					case 0: number = 502261; break; // HELP!
+					case 1: number = 502262; break; // Help me!
+					case 2: number = 502263; break; // Canst thou aid me?!
+					case 3: number = 502264; break; // Help a poor prisoner!
+					case 4: number = 502265; break; // Help! Please!
+					case 5: number = 502266; break; // Aaah! Help me!
+					case 6: number = 502267; break; // Go and get some help!
+					default: number = 502268; break; // Quickly, I beg thee! Unlock my chains! If thou dost look at me close thou canst see them.	
+				}
+				m_Prisoner.Yell( number );
+			}
+		}
+
+		// Don't refresh decay timer
+		public override void OnExit(Mobile m)
+		{
+		}
+
+		public LizardmenCamp( Serial serial ) : base( serial )
+		{
+		}
+		
+		public override void AddItem( Item item, int xOffset, int yOffset, int zOffset )
+		{
+			if ( item != null )
+				item.Movable = false;
+				
+			base.AddItem( item, xOffset, yOffset, zOffset );
+		}
+			
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+
+			writer.Write( m_Prisoner );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 0:
+				{
+					m_Prisoner = reader.ReadMobile();
+					break;
+				}
+			}
+		}
+	}
+}

Scripts/Multis/Camps/MageCamp.cs

@@ -0,0 +1,49 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Mobiles;
+
+namespace Server.Multis
+{
+	public class MageCamp : BaseCamp
+	{
+		[Constructable]
+		public MageCamp() : base( 0x1F5 )
+		{
+		}
+
+		public override void AddComponents()
+		{
+			BaseDoor west, east;
+
+			AddItem( west = new LightWoodGate( DoorFacing.WestCW ), -4, 4, 7 );
+			AddItem( east = new LightWoodGate( DoorFacing.EastCCW ), -3, 4, 7 );
+
+			west.Link = east;
+			east.Link = west;
+
+			AddItem( new Sign( SignType.Mage, SignFacing.West ), -5, 5, -4 );
+
+			AddMobile( new Mage(), 4, -4,  3, 7 );
+			AddMobile( new Mage(), 5,  4, -2, 0 );
+		}
+
+		public MageCamp( 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/Multis/Camps/OrcCamp.cs

@@ -0,0 +1,200 @@
+using System;
+using Server.Items;
+using Server.Mobiles;
+
+namespace Server.Multis
+{
+	public class OrcCamp : BaseCamp
+	{
+		public virtual Mobile Orcs{ get{ return new Orc(); } }
+
+		private Mobile m_Prisoner;
+		
+		[Constructable]
+		public OrcCamp() : base( 0x10EE ) // dummy garbage at center
+		{
+		}
+
+		public override void AddComponents()
+		{
+			BaseCreature bc;
+			//BaseEscortable be;
+
+			Visible = false;
+			DecayDelay = TimeSpan.FromMinutes(5.0);
+			AddItem(new Static(0x10ee), 0, 0, 0);
+			AddItem(new Static(0xfac), 0, 7, 0);
+						
+			switch ( Utility.Random( 3 ) )
+			{
+				case 0:
+				{
+					AddItem( new Item( 0xDE3 ), 0, 7, 0 ); // Campfire
+					AddItem( new Item( 0x974 ), 0, 7, 1 ); // Cauldron
+					break;
+				}
+				case 1:
+				{
+					AddItem( new Item( 0x1E95 ), 0, 7, 1 ); // Rabbit on a spit
+					break;
+				}
+				default:
+				{
+					AddItem( new Item( 0x1E94 ), 0, 7, 1 ); // Chicken on a spit
+					break;
+				}
+			}
+			AddItem(new Item(0x428), -5, -4, 0); // Gruesome Standart West
+
+			AddCampChests();
+			
+			for ( int i = 0; i < 3; i ++ )
+			{				
+				AddMobile( Orcs, 6, Utility.RandomMinMax( -7, 7 ), Utility.RandomMinMax( -7, 7 ), 0 );
+			}
+			AddMobile( new OrcCaptain(), 2, Utility.RandomMinMax( -7, 7 ), Utility.RandomMinMax( -7, 7 ), 0 );
+			
+			switch ( Utility.Random( 2 ) )
+			{
+				case 0: m_Prisoner = new Noble(); break;
+				default: m_Prisoner = new SeekerOfAdventure(); break;
+			}
+			
+			//be = (BaseEscortable)m_Prisoner;
+			//be.m_Captive = true;
+			
+			bc = (BaseCreature)m_Prisoner;
+			bc.IsPrisoner = true;
+			bc.CantWalk = true;
+			
+			m_Prisoner.YellHue = Utility.RandomList( 0x57, 0x67, 0x77, 0x87, 0x117 );
+			AddMobile( m_Prisoner, 2, Utility.RandomMinMax( -2, 2 ), Utility.RandomMinMax( -2, 2 ), 0 );
+		}
+
+		private void AddCampChests()
+		{
+			LockableContainer chest = null;
+
+			switch (Utility.Random(3))
+			{
+				case 0: chest = new MetalChest(); break;
+				case 1: chest = new MetalGoldenChest(); break;
+				default: chest = new WoodenChest(); break;
+			}
+
+			chest.LiftOverride = true;
+
+			TreasureMapChest.Fill(chest, 1);
+
+			AddItem(chest, -2, 2, 0);
+
+			LockableContainer crates = null;
+
+			switch (Utility.Random(4))
+			{
+				case 0: crates = new SmallCrate(); break;
+				case 1: crates = new MediumCrate(); break;
+				case 2: crates = new LargeCrate(); break;
+				default: crates = new LockableBarrel(); break;
+			}
+
+			crates.TrapType = TrapType.ExplosionTrap;
+			crates.TrapPower = Utility.RandomMinMax(30, 40);
+			crates.TrapLevel = 2;
+
+			crates.RequiredSkill = 76;
+			crates.LockLevel = 66;
+			crates.MaxLockLevel = 116;
+			crates.Locked = true;
+
+			crates.DropItem(new Gold(Utility.RandomMinMax(100, 400)));
+			crates.DropItem(new Arrow(10));
+			crates.DropItem(new Bolt(10));
+
+			crates.LiftOverride = true;
+
+			if (Utility.RandomDouble() < 0.8)
+			{
+				switch (Utility.Random(4))
+				{
+					case 0: crates.DropItem(new LesserCurePotion()); break;
+					case 1: crates.DropItem(new LesserExplosionPotion()); break;
+					case 2: crates.DropItem(new LesserHealPotion()); break;
+					default: crates.DropItem(new LesserPoisonPotion()); break;
+				}
+			}
+
+			AddItem(crates, 2, -2, 0);
+		}
+
+		// Don't refresh decay timer
+		public override void OnEnter(Mobile m)
+		{
+			if ( m.Player && m_Prisoner != null && m_Prisoner.CantWalk )
+			{
+				int number;
+
+				switch ( Utility.Random( 8 ) )
+				{
+					case 0: number = 502261; break; // HELP!
+					case 1: number = 502262; break; // Help me!
+					case 2: number = 502263; break; // Canst thou aid me?!
+					case 3: number = 502264; break; // Help a poor prisoner!
+					case 4: number = 502265; break; // Help! Please!
+					case 5: number = 502266; break; // Aaah! Help me!
+					case 6: number = 502267; break; // Go and get some help!
+					default: number = 502268; break; // Quickly, I beg thee! Unlock my chains! If thou dost look at me close thou canst see them.	
+				}
+				m_Prisoner.Yell( number );
+			}
+		}
+
+		// Don't refresh decay timer
+		public override void OnExit(Mobile m)
+		{
+		}
+
+		public OrcCamp( Serial serial ) : base( serial )
+		{
+		}
+		
+		public override void AddItem( Item item, int xOffset, int yOffset, int zOffset )
+		{
+			if ( item != null )
+				item.Movable = false;
+				
+			base.AddItem( item, xOffset, yOffset, zOffset );
+		}
+			
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 1 ); // version
+
+			writer.Write( m_Prisoner );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 1:
+				{
+					m_Prisoner = reader.ReadMobile();
+					break;
+				}
+				case 0:
+				{
+					m_Prisoner = reader.ReadMobile();
+					reader.ReadItem();
+					break;
+				}
+			}
+		}
+	}
+}

Scripts/Multis/Camps/RatCamp.cs

@@ -0,0 +1,199 @@
+using System;
+using Server.Items;
+using Server.Mobiles;
+
+namespace Server.Multis
+{
+	public class RatCamp : BaseCamp
+	{
+		public virtual Mobile Ratmen{ get{ return new Ratman(); } }
+
+		private Mobile m_Prisoner;
+		
+		[Constructable]
+		public RatCamp() : base( 0x10EE ) // dummy garbage at center
+		{
+		}
+
+		public override void AddComponents()
+		{
+			BaseCreature bc;
+			//BaseEscortable be;
+
+			Visible = false;
+			DecayDelay = TimeSpan.FromMinutes(5.0);
+			AddItem(new Static(0x10ee), 0, 0, 0);
+			AddItem(new Static(0xfac), 0, 6, 0);
+			
+			switch ( Utility.Random( 3 ) )
+			{
+				case 0:
+				{
+					AddItem( new Item( 0xDE3 ), 0, 6, 0 ); // Campfire
+					AddItem( new Item( 0x974 ), 0, 6, 1 ); // Cauldron
+					break;
+				}
+				case 1:
+				{
+					AddItem( new Item( 0x1E95 ), 0, 6, 1 ); // Rabbit on a spit
+					break;
+				}
+				default:
+				{
+					AddItem( new Item( 0x1E94 ), 0, 6, 1 ); // Chicken on a spit
+					break;
+				}
+			}
+			AddItem(new Item(0x41F), 5, 5, 0); // Gruesome Standart South
+
+			AddCampChests();
+			
+			for ( int i = 0; i < 4; i ++ )
+			{				
+				AddMobile( Ratmen, 6, Utility.RandomMinMax( -7, 7 ), Utility.RandomMinMax( -7, 7 ), 0 );
+			}
+			
+			switch ( Utility.Random( 2 ) )
+			{
+				case 0: m_Prisoner = new Noble(); break;
+				default: m_Prisoner = new SeekerOfAdventure(); break;
+			}
+			
+			//be = (BaseEscortable)m_Prisoner;
+			//be.m_Captive = true;
+			
+			bc = (BaseCreature)m_Prisoner;
+			bc.IsPrisoner = true;
+			bc.CantWalk = true;
+			
+			m_Prisoner.YellHue = Utility.RandomList( 0x57, 0x67, 0x77, 0x87, 0x117 );
+			AddMobile( m_Prisoner, 2, Utility.RandomMinMax( -2, 2 ), Utility.RandomMinMax( -2, 2 ), 0 );
+		}
+
+		private void AddCampChests()
+		{
+			LockableContainer chest = null;
+
+			switch (Utility.Random(3))
+			{
+				case 0: chest = new MetalChest(); break;
+				case 1: chest = new MetalGoldenChest(); break;
+				default: chest = new WoodenChest(); break;
+			}
+
+			chest.LiftOverride = true;
+
+			TreasureMapChest.Fill(chest, 1);
+
+			AddItem(chest, -2, -2, 0);
+
+			LockableContainer crates = null;
+
+			switch (Utility.Random(4))
+			{
+				case 0: crates = new SmallCrate(); break;
+				case 1: crates = new MediumCrate(); break;
+				case 2: crates = new LargeCrate(); break;
+				default: crates = new LockableBarrel(); break;
+			}
+
+			crates.TrapType = TrapType.ExplosionTrap;
+			crates.TrapPower = Utility.RandomMinMax(30, 40);
+			crates.TrapLevel = 2;
+
+			crates.RequiredSkill = 76;
+			crates.LockLevel = 66;
+			crates.MaxLockLevel = 116;
+			crates.Locked = true;
+
+			crates.DropItem(new Gold(Utility.RandomMinMax(100, 400)));
+			crates.DropItem(new Arrow(10));
+			crates.DropItem(new Bolt(10));
+
+			crates.LiftOverride = true;
+
+			if (Utility.RandomDouble() < 0.8)
+			{
+				switch (Utility.Random(4))
+				{
+					case 0: crates.DropItem(new LesserCurePotion()); break;
+					case 1: crates.DropItem(new LesserExplosionPotion()); break;
+					case 2: crates.DropItem(new LesserHealPotion()); break;
+					default: crates.DropItem(new LesserPoisonPotion()); break;
+				}
+			}
+
+			AddItem(crates, 2, 2, 0);
+		}
+
+		// Don't refresh decay timer
+		public override void OnEnter(Mobile m)
+		{
+			if ( m.Player && m_Prisoner != null && m_Prisoner.CantWalk )
+			{
+				int number;
+
+				switch ( Utility.Random( 8 ) )
+				{
+					case 0: number = 502261; break; // HELP!
+					case 1: number = 502262; break; // Help me!
+					case 2: number = 502263; break; // Canst thou aid me?!
+					case 3: number = 502264; break; // Help a poor prisoner!
+					case 4: number = 502265; break; // Help! Please!
+					case 5: number = 502266; break; // Aaah! Help me!
+					case 6: number = 502267; break; // Go and get some help!
+					default: number = 502268; break; // Quickly, I beg thee! Unlock my chains! If thou dost look at me close thou canst see them.	
+				}
+				m_Prisoner.Yell( number );
+			}
+		}
+
+		// Don't refresh decay timer
+		public override void OnExit(Mobile m)
+		{
+		}
+
+		public RatCamp( Serial serial ) : base( serial )
+		{
+		}
+		
+		public override void AddItem( Item item, int xOffset, int yOffset, int zOffset )
+		{
+			if ( item != null )
+				item.Movable = false;
+				
+			base.AddItem( item, xOffset, yOffset, zOffset );
+		}
+			
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 1 ); // version
+
+			writer.Write( m_Prisoner );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 1:
+				{
+					m_Prisoner = reader.ReadMobile();
+					break;
+				}
+				case 0:
+				{
+					m_Prisoner = reader.ReadMobile();
+					reader.ReadItem();
+					break;
+				}
+			}
+		}
+	}
+}

Scripts/Multis/ComponentVerification.cs

@@ -0,0 +1,254 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Server.Multis
+{
+	public class ComponentVerification
+	{
+		private int[] m_ItemTable;
+		private int[] m_MultiTable;
+
+		public bool IsItemValid( int itemID )
+		{
+			if ( itemID <= 0 || itemID >= m_ItemTable.Length )
+				return false;
+
+			return CheckValidity( m_ItemTable[itemID] );
+		}
+
+		public bool IsMultiValid( int multiID )
+		{
+			if ( multiID <= 0 || multiID >= m_MultiTable.Length )
+				return false;
+
+			return CheckValidity( m_MultiTable[multiID] );
+		}
+
+		public bool CheckValidity( int val )
+		{
+			if ( val == -1 )
+				return false;
+
+			return ( val == 0 || ((int)ExpansionInfo.CoreExpansion.CustomHousingFlag & val) != 0 );
+		}
+
+		public ComponentVerification()
+		{
+			m_ItemTable = CreateTable( TileData.MaxItemValue );
+			m_MultiTable = CreateTable( 0x4000 );
+
+			LoadItems( "Data/Components/walls.txt", "South1", "South2", "South3", "Corner", "East1", "East2", "East3", "Post", "WindowS", "AltWindowS", "WindowE", "AltWindowE", "SecondAltWindowS", "SecondAltWindowE" );
+			LoadItems( "Data/Components/teleprts.txt", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12", "F13", "F14", "F15", "F16" );
+			LoadItems( "Data/Components/stairs.txt", "Block", "North", "East", "South", "West", "Squared1", "Squared2", "Rounded1", "Rounded2" );
+			LoadItems( "Data/Components/roof.txt", "North", "East", "South", "West", "NSCrosspiece", "EWCrosspiece", "NDent", "EDent", "SDent", "WDent", "NTPiece", "ETPiece", "STPiece", "WTPiece", "XPiece", "Extra Piece" );
+			LoadItems( "Data/Components/floors.txt", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12", "F13", "F14", "F15", "F16" );
+			LoadItems( "Data/Components/misc.txt", "Piece1", "Piece2", "Piece3", "Piece4", "Piece5", "Piece6", "Piece7", "Piece8" );
+			LoadItems( "Data/Components/doors.txt", "Piece1", "Piece2", "Piece3", "Piece4", "Piece5", "Piece6", "Piece7", "Piece8" );
+
+			LoadMultis( "Data/Components/stairs.txt", "MultiNorth", "MultiEast", "MultiSouth", "MultiWest" );
+		}
+
+		private int[] CreateTable( int length )
+		{
+			int[] table = new int[length];
+
+			for ( int i = 0; i < table.Length; ++i )
+				table[i] = -1;
+
+			return table;
+		}
+
+		private void LoadItems( string path, params string[] itemColumns )
+		{
+			LoadSpreadsheet( m_ItemTable, path, itemColumns );
+		}
+
+		private void LoadMultis( string path, params string[] multiColumns )
+		{
+			LoadSpreadsheet( m_MultiTable, path, multiColumns );
+		}
+
+		private void LoadSpreadsheet( int[] table, string path, params string[] tileColumns )
+		{
+			Spreadsheet ss = new Spreadsheet( path );
+
+			int[] tileCIDs = new int[tileColumns.Length];
+
+			for ( int i = 0; i < tileColumns.Length; ++i )
+				tileCIDs[i] = ss.GetColumnID( tileColumns[i] );
+
+			int featureCID = ss.GetColumnID( "FeatureMask" );
+
+			for ( int i = 0; i < ss.Records.Length; ++i )
+			{
+				DataRecord record = ss.Records[i];
+
+				int fid = record.GetInt32( featureCID );
+
+				for ( int j = 0; j < tileCIDs.Length; ++j )
+				{
+					int itemID = record.GetInt32( tileCIDs[j] );
+
+					if ( itemID <= 0 || itemID >= table.Length )
+						continue;
+
+					table[itemID] = fid;
+				}
+			}
+		}
+	}
+
+	public class Spreadsheet
+	{
+		private class ColumnInfo
+		{
+			public int m_DataIndex;
+
+			public string m_Type;
+			public string m_Name;
+
+			public ColumnInfo( int dataIndex, string type, string name )
+			{
+				m_DataIndex = dataIndex;
+
+				m_Type = type;
+				m_Name = name;
+			}
+		}
+
+		private ColumnInfo[] m_Columns;
+		private DataRecord[] m_Records;
+
+		public DataRecord[] Records { get { return m_Records; } }
+
+		public int GetColumnID( string name )
+		{
+			for ( int i = 0; i < m_Columns.Length; ++i )
+			{
+				if ( m_Columns[i].m_Name == name )
+					return i;
+			}
+
+			return -1;
+		}
+
+		public Spreadsheet( string path )
+		{
+			using ( StreamReader ip = new StreamReader( path ) )
+			{
+				string[] types = ReadLine( ip );
+				string[] names = ReadLine( ip );
+
+				m_Columns = new ColumnInfo[types.Length];
+
+				for ( int i = 0; i < m_Columns.Length; ++i )
+					m_Columns[i] = new ColumnInfo( i, types[i], names[i] );
+
+				List<DataRecord> records = new List<DataRecord>();
+
+				string[] values;
+
+				while ( ( values = ReadLine( ip ) ) != null )
+				{
+					object[] data = new object[m_Columns.Length];
+
+					for ( int i = 0; i < m_Columns.Length; ++i )
+					{
+						ColumnInfo ci = m_Columns[i];
+
+						switch ( ci.m_Type )
+						{
+							case "int":
+								{
+									data[i] = Utility.ToInt32( values[ci.m_DataIndex] );
+									break;
+								}
+							case "string":
+								{
+									data[i] = values[ci.m_DataIndex];
+									break;
+								}
+						}
+					}
+
+					records.Add( new DataRecord( this, data ) );
+				}
+
+				m_Records = records.ToArray();
+			}
+		}
+
+		private string[] ReadLine( StreamReader ip )
+		{
+			string line;
+
+			while ( ( line = ip.ReadLine() ) != null )
+			{
+				if ( line.Length == 0 )
+					continue;
+
+				return line.Split( '\t' );
+			}
+
+			return null;
+		}
+	}
+
+	public class DataRecord
+	{
+		private Spreadsheet m_Spreadsheet;
+		private object[] m_Data;
+
+		public Spreadsheet Spreadsheet { get { return m_Spreadsheet; } }
+		public object[] Data { get { return m_Data; } }
+
+		public DataRecord( Spreadsheet ss, object[] data )
+		{
+			m_Spreadsheet = ss;
+			m_Data = data;
+		}
+
+		public int GetInt32( string name )
+		{
+			return GetInt32( this[name] );
+		}
+
+		public int GetInt32( int id )
+		{
+			return GetInt32( this[id] );
+		}
+
+		public int GetInt32( object obj )
+		{
+			if ( obj is int )
+				return (int) obj;
+
+			return 0;
+		}
+
+		public string GetString( string name )
+		{
+			return this[name] as string;
+		}
+
+		public object this[string name]
+		{
+			get
+			{
+				return this[m_Spreadsheet.GetColumnID( name )];
+			}
+		}
+
+		public object this[int id]
+		{
+			get
+			{
+				if ( id < 0 )
+					return null;
+
+				return m_Data[id];
+			}
+		}
+	}
+}

Scripts/Multis/Deeds.cs

@@ -0,0 +1,902 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Multis;
+using Server.Targeting;
+using Server.Items;
+using Server.Regions;
+
+namespace Server.Multis.Deeds
+{
+	public class HousePlacementTarget : MultiTarget
+	{
+		private HouseDeed m_Deed;
+
+		public HousePlacementTarget( HouseDeed deed ) : base( deed.MultiID, deed.Offset )
+		{
+			m_Deed = deed;
+		}
+
+		protected override void OnTarget( Mobile from, object o )
+		{
+			IPoint3D ip = o as IPoint3D;
+
+			if ( ip != null )
+			{
+				if ( ip is Item )
+					ip = ((Item)ip).GetWorldTop();
+
+				Point3D p = new Point3D( ip );
+
+				Region reg = Region.Find( new Point3D( p ), from.Map );
+
+				if ( from.AccessLevel >= AccessLevel.GameMaster || reg.AllowHousing( from, p ) )
+					m_Deed.OnPlacement( from, p );
+				else if ( reg.IsPartOf( typeof( TempNoHousingRegion ) ) )
+					from.SendLocalizedMessage( 501270 ); // Lord British has decreed a 'no build' period, thus you cannot build this house at this time.
+				else if ( reg.IsPartOf( typeof( TreasureRegion ) ) || reg.IsPartOf( typeof( HouseRegion ) ) )
+					from.SendLocalizedMessage( 1043287 ); // The house could not be created here.  Either something is blocking the house, or the house would not be on valid terrain.
+				else if ( reg.IsPartOf( typeof( HouseRaffleRegion ) ) )
+					from.SendLocalizedMessage( 1150493 ); // You must have a deed for this plot of land in order to build here.
+				else
+					from.SendLocalizedMessage( 501265 ); // Housing can not be created in this area.
+			}
+		}
+	}
+
+	public abstract class HouseDeed : Item
+	{
+		private int m_MultiID;
+		private Point3D m_Offset;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int MultiID
+		{
+			get
+			{
+				return m_MultiID;
+			}
+			set
+			{
+				m_MultiID = value;
+			}
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public Point3D Offset
+		{
+			get
+			{
+				return m_Offset;
+			}
+			set
+			{
+				m_Offset = value;
+			}
+		}
+
+		public HouseDeed( int id, Point3D offset ) : base( 0x14F0 )
+		{
+			Weight = 1.0;
+			LootType = LootType.Newbied;
+
+			m_MultiID = id;
+			m_Offset = offset;
+		}
+
+		public HouseDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 1 ); // version
+
+			writer.Write( m_Offset );
+
+			writer.Write( m_MultiID );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 1:
+				{
+					m_Offset = reader.ReadPoint3D();
+
+					goto case 0;
+				}
+				case 0:
+				{
+					m_MultiID = reader.ReadInt();
+
+					break;
+				}
+			}
+
+			if ( Weight == 0.0 )
+				Weight = 1.0;
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( !IsChildOf( from.Backpack ) )
+			{
+				from.SendLocalizedMessage( 1042001 ); // That must be in your pack for you to use it.
+			}
+			else if ( from.AccessLevel < AccessLevel.GameMaster && BaseHouse.HasAccountHouse( from ) )
+			{
+				from.SendLocalizedMessage( 501271 ); // You already own a house, you may not place another!
+			}
+			else
+			{
+				from.SendLocalizedMessage( 1010433 ); /* House placement cancellation could result in a
+													   * 60 second delay in the return of your deed.
+													   */
+
+				from.Target = new HousePlacementTarget( this );
+			}
+		}
+
+		public abstract BaseHouse GetHouse( Mobile owner );
+		public abstract Rectangle2D[] Area{ get; }
+
+		public void OnPlacement( Mobile from, Point3D p )
+		{
+			if ( Deleted )
+				return;
+
+			if ( !IsChildOf( from.Backpack ) )
+			{
+				from.SendLocalizedMessage( 1042001 ); // That must be in your pack for you to use it.
+			}
+			else if ( from.AccessLevel < AccessLevel.GameMaster && BaseHouse.HasAccountHouse( from ) )
+			{
+				from.SendLocalizedMessage( 501271 ); // You already own a house, you may not place another!
+			}
+			else
+			{
+				ArrayList toMove;
+				Point3D center = new Point3D( p.X - m_Offset.X, p.Y - m_Offset.Y, p.Z - m_Offset.Z );
+				HousePlacementResult res = HousePlacement.Check( from, m_MultiID, center, out toMove );
+
+				switch ( res )
+				{
+					case HousePlacementResult.Valid:
+					{
+						BaseHouse house = GetHouse( from );
+						house.MoveToWorld( center, from.Map );
+						Delete();
+
+						for ( int i = 0; i < toMove.Count; ++i )
+						{
+							object o = toMove[i];
+
+							if ( o is Mobile )
+								((Mobile)o).Location = house.BanLocation;
+							else if ( o is Item )
+								((Item)o).Location = house.BanLocation;
+						}
+
+						break;
+					}
+					case HousePlacementResult.BadItem:
+					case HousePlacementResult.BadLand:
+					case HousePlacementResult.BadStatic:
+					case HousePlacementResult.BadRegionHidden:
+					{
+						from.SendLocalizedMessage( 1043287 ); // The house could not be created here.  Either something is blocking the house, or the house would not be on valid terrain.
+						break;
+					}
+					case HousePlacementResult.NoSurface:
+					{
+						from.SendMessage( "The house could not be created here.  Part of the foundation would not be on any surface." );
+						break;
+					}
+					case HousePlacementResult.BadRegion:
+					{
+						from.SendLocalizedMessage( 501265 ); // Housing cannot be created in this area.
+						break;
+					}
+					case HousePlacementResult.BadRegionTemp:
+					{
+						from.SendLocalizedMessage( 501270 ); //Lord British has decreed a 'no build' period, thus you cannot build this house at this time.
+						break;
+					}
+					case HousePlacementResult.BadRegionRaffle:
+					{
+						from.SendLocalizedMessage( 1150493 ); // You must have a deed for this plot of land in order to build here.
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	public class StonePlasterHouseDeed : HouseDeed
+	{
+		[Constructable]
+		public StonePlasterHouseDeed() : base( 0x64, new Point3D( 0, 4, 0 ) )
+		{
+		}
+
+		public StonePlasterHouseDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new SmallOldHouse( owner, 0x64 );
+		}
+
+		public override int LabelNumber{ get{ return 1041211; } }
+		public override Rectangle2D[] Area{ get{ return SmallOldHouse.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class FieldStoneHouseDeed : HouseDeed
+	{
+		[Constructable]
+		public FieldStoneHouseDeed() : base( 0x66, new Point3D( 0, 4, 0 ) )
+		{
+		}
+
+		public FieldStoneHouseDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new SmallOldHouse( owner, 0x66 );
+		}
+
+		public override int LabelNumber{ get{ return 1041212; } }
+		public override Rectangle2D[] Area{ get{ return SmallOldHouse.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class SmallBrickHouseDeed : HouseDeed
+	{
+		[Constructable]
+		public SmallBrickHouseDeed() : base( 0x68, new Point3D( 0, 4, 0 ) )
+		{
+		}
+
+		public SmallBrickHouseDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new SmallOldHouse( owner, 0x68 );
+		}
+
+		public override int LabelNumber{ get{ return 1041213; } }
+		public override Rectangle2D[] Area{ get{ return SmallOldHouse.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class WoodHouseDeed : HouseDeed
+	{
+		[Constructable]
+		public WoodHouseDeed() : base( 0x6A, new Point3D( 0, 4, 0 ) )
+		{
+		}
+
+		public WoodHouseDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new SmallOldHouse( owner, 0x6A );
+		}
+
+		public override int LabelNumber{ get{ return 1041214; } }
+		public override Rectangle2D[] Area{ get{ return SmallOldHouse.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class WoodPlasterHouseDeed : HouseDeed
+	{
+		[Constructable]
+		public WoodPlasterHouseDeed() : base( 0x6C, new Point3D( 0, 4, 0 ) )
+		{
+		}
+
+		public WoodPlasterHouseDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new SmallOldHouse( owner, 0x6C );
+		}
+
+		public override int LabelNumber{ get{ return 1041215; } }
+		public override Rectangle2D[] Area{ get{ return SmallOldHouse.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class ThatchedRoofCottageDeed : HouseDeed
+	{
+		[Constructable]
+		public ThatchedRoofCottageDeed() : base( 0x6E, new Point3D( 0, 4, 0 ) )
+		{
+		}
+
+		public ThatchedRoofCottageDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new SmallOldHouse( owner, 0x6E );
+		}
+
+		public override int LabelNumber{ get{ return 1041216; } }
+		public override Rectangle2D[] Area{ get{ return SmallOldHouse.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class BrickHouseDeed : HouseDeed
+	{
+		[Constructable]
+		public BrickHouseDeed() : base( 0x74, new Point3D( -1, 7, 0 ) )
+		{
+		}
+
+		public BrickHouseDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new GuildHouse( owner );
+		}
+
+		public override int LabelNumber{ get{ return 1041219; } }
+		public override Rectangle2D[] Area{ get{ return GuildHouse.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class TwoStoryWoodPlasterHouseDeed : HouseDeed
+	{
+		[Constructable]
+		public TwoStoryWoodPlasterHouseDeed() : base( 0x76, new Point3D( -3, 7, 0 ) )
+		{
+		}
+
+		public TwoStoryWoodPlasterHouseDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new TwoStoryHouse( owner, 0x76 );
+		}
+
+		public override int LabelNumber{ get{ return 1041220; } }
+		public override Rectangle2D[] Area{ get{ return TwoStoryHouse.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class TwoStoryStonePlasterHouseDeed : HouseDeed
+	{
+		[Constructable]
+		public TwoStoryStonePlasterHouseDeed() : base( 0x78, new Point3D( -3, 7, 0 ) )
+		{
+		}
+
+		public TwoStoryStonePlasterHouseDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new TwoStoryHouse( owner, 0x78 );
+		}
+
+		public override int LabelNumber{ get{ return 1041221; } }
+		public override Rectangle2D[] Area{ get{ return TwoStoryHouse.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class TowerDeed : HouseDeed
+	{
+		[Constructable]
+		public TowerDeed() : base( 0x7A, new Point3D( 0, 7, 0 ) )
+		{
+		}
+
+		public TowerDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new Tower( owner );
+		}
+
+		public override int LabelNumber{ get{ return 1041222; } }
+		public override Rectangle2D[] Area{ get{ return Tower.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class KeepDeed : HouseDeed
+	{
+		[Constructable]
+		public KeepDeed() : base( 0x7C, new Point3D( 0, 11, 0 ) )
+		{
+		}
+
+		public KeepDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new Keep( owner );
+		}
+
+		public override int LabelNumber{ get{ return 1041223; } }
+		public override Rectangle2D[] Area{ get{ return Keep.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class CastleDeed : HouseDeed
+	{
+		[Constructable]
+		public CastleDeed() : base( 0x7E, new Point3D( 0, 16, 0 ) )
+		{
+		}
+
+		public CastleDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new Castle( owner );
+		}
+
+		public override int LabelNumber{ get{ return 1041224; } }
+		public override Rectangle2D[] Area{ get{ return Castle.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class LargePatioDeed : HouseDeed
+	{
+		[Constructable]
+		public LargePatioDeed() : base( 0x8C, new Point3D( -4, 7, 0 ) )
+		{
+		}
+
+		public LargePatioDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new LargePatioHouse( owner );
+		}
+
+		public override int LabelNumber{ get{ return 1041231; } }
+		public override Rectangle2D[] Area{ get{ return LargePatioHouse.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class LargeMarbleDeed : HouseDeed
+	{
+		[Constructable]
+		public LargeMarbleDeed() : base( 0x96, new Point3D( -4, 7, 0 ) )
+		{
+		}
+
+		public LargeMarbleDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new LargeMarbleHouse( owner );
+		}
+
+		public override int LabelNumber{ get{ return 1041236; } }
+		public override Rectangle2D[] Area{ get{ return LargeMarbleHouse.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class SmallTowerDeed : HouseDeed
+	{
+		[Constructable]
+		public SmallTowerDeed() : base( 0x98, new Point3D( 3, 4, 0 ) )
+		{
+		}
+
+		public SmallTowerDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new SmallTower( owner );
+		}
+
+		public override int LabelNumber{ get{ return 1041237; } }
+		public override Rectangle2D[] Area{ get{ return SmallTower.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class LogCabinDeed : HouseDeed
+	{
+		[Constructable]
+		public LogCabinDeed() : base( 0x9A, new Point3D( 1, 6, 0 ) )
+		{
+		}
+
+		public LogCabinDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new LogCabin( owner );
+		}
+
+		public override int LabelNumber{ get{ return 1041238; } }
+		public override Rectangle2D[] Area{ get{ return LogCabin.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class SandstonePatioDeed : HouseDeed
+	{
+		[Constructable]
+		public SandstonePatioDeed() : base( 0x9C, new Point3D( -1, 4, 0 ) )
+		{
+		}
+
+		public SandstonePatioDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new SandStonePatio( owner );
+		}
+
+		public override int LabelNumber{ get{ return 1041239; } }
+		public override Rectangle2D[] Area{ get{ return SandStonePatio.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class VillaDeed : HouseDeed
+	{
+		[Constructable]
+		public VillaDeed() : base( 0x9E, new Point3D( 3, 6, 0 ) )
+		{
+		}
+
+		public VillaDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new TwoStoryVilla( owner );
+		}
+
+		public override int LabelNumber{ get{ return 1041240; } }
+		public override Rectangle2D[] Area{ get{ return TwoStoryVilla.AreaArray; } }
+
+		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();
+		}
+	}
+
+	public class StoneWorkshopDeed : HouseDeed
+	{
+		[Constructable]
+		public StoneWorkshopDeed() : base( 0xA0, new Point3D( -1, 4, 0 ) )
+		{
+		}
+
+		public StoneWorkshopDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new SmallShop( owner, 0xA0 );
+		}
+
+		public override int LabelNumber{ get{ return 1041241; } }
+		public override Rectangle2D[] Area{ get{ return SmallShop.AreaArray2; } }
+
+		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();
+		}
+	}
+
+	public class MarbleWorkshopDeed : HouseDeed
+	{
+		[Constructable]
+		public MarbleWorkshopDeed() : base( 0xA2, new Point3D( -1, 4, 0 ) )
+		{
+		}
+
+		public MarbleWorkshopDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override BaseHouse GetHouse( Mobile owner )
+		{
+			return new SmallShop( owner, 0xA2 );
+		}
+
+		public override int LabelNumber{ get{ return 1041242; } }
+		public override Rectangle2D[] Area{ get{ return SmallShop.AreaArray1; } }
+
+		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/Multis/DynamicDecay.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using Server;
+
+namespace Server.Multis
+{
+	public class DynamicDecay
+	{
+		public static bool Enabled { get { return Core.ML; } }
+
+		private static Dictionary<DecayLevel, DecayStageInfo> m_Stages;
+
+		static DynamicDecay()
+		{
+			m_Stages = new Dictionary<DecayLevel, DecayStageInfo>();
+
+			Register( DecayLevel.LikeNew,		TimeSpan.FromHours( 1 ),	TimeSpan.FromHours( 1 )		);
+			Register( DecayLevel.Slightly,		TimeSpan.FromDays( 1 ),		TimeSpan.FromDays( 2 )		);
+			Register( DecayLevel.Somewhat,		TimeSpan.FromDays( 1 ),		TimeSpan.FromDays( 2 )		);
+			Register( DecayLevel.Fairly,		TimeSpan.FromDays( 1 ),		TimeSpan.FromDays( 2 )		);
+			Register( DecayLevel.Greatly,		TimeSpan.FromDays( 1 ),		TimeSpan.FromDays( 2 )		);
+			Register( DecayLevel.IDOC,			TimeSpan.FromHours( 12 ),	TimeSpan.FromHours( 24 )	);
+		}
+
+		public static void Register( DecayLevel level, TimeSpan min, TimeSpan max )
+		{
+			DecayStageInfo info = new DecayStageInfo( min, max );
+
+			if ( m_Stages.ContainsKey( level ) )
+				m_Stages[level] = info;
+			else
+				m_Stages.Add( level, info );
+		}
+
+		public static bool Decays( DecayLevel level )
+		{
+			return m_Stages.ContainsKey( level );
+		}
+
+		public static TimeSpan GetRandomDuration( DecayLevel level )
+		{
+			if ( !m_Stages.ContainsKey( level ) )
+				return TimeSpan.Zero;
+
+			DecayStageInfo info = m_Stages[level];
+			long min = info.MinDuration.Ticks;
+			long max = info.MaxDuration.Ticks;
+
+			return TimeSpan.FromTicks( min + (long)( Utility.RandomDouble() * ( max - min ) ) );
+		}
+	}
+
+	public class DecayStageInfo
+	{
+		private TimeSpan m_MinDuration;
+		private TimeSpan m_MaxDuration;
+
+		public TimeSpan MinDuration
+		{
+			get { return m_MinDuration; }
+		}
+
+		public TimeSpan MaxDuration
+		{
+			get { return m_MaxDuration; }
+		}
+
+		public DecayStageInfo( TimeSpan min, TimeSpan max )
+		{
+			m_MinDuration = min;
+			m_MaxDuration = max;
+		}
+	}
+}

Scripts/Multis/HousePlacement.cs

@@ -0,0 +1,378 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server;
+using Server.Guilds;
+using Server.Items;
+using Server.Misc;
+using Server.Regions;
+using Server.Spells;
+
+namespace Server.Multis
+{
+	public enum HousePlacementResult
+	{
+		Valid,
+		BadRegion,
+		BadLand,
+		BadStatic,
+		BadItem,
+		NoSurface,
+		BadRegionHidden,
+		BadRegionTemp,
+		InvalidCastleKeep,
+		BadRegionRaffle
+	}
+
+	public class HousePlacement
+	{
+		private const int YardSize = 5;
+
+		// Any land tile which matches one of these ID numbers is considered a road and cannot be placed over.
+		private static int[] m_RoadIDs = new int[]
+			{
+				0x0071, 0x0078,
+				0x00E8, 0x00EB,
+				0x07AE, 0x07B1,
+				0x3FF4, 0x3FF4,
+				0x3FF8, 0x3FFB,
+				0x0442, 0x0479, // Sand stones
+				0x0501, 0x0510, // Sand stones
+				0x0009, 0x0015, // Furrows
+				0x0150, 0x015C  // Furrows
+			};
+
+		public static HousePlacementResult Check( Mobile from, int multiID, Point3D center, out ArrayList toMove )
+		{
+			// If this spot is considered valid, every item and mobile in this list will be moved under the house sign
+			toMove = new ArrayList();
+
+			Map map = from.Map;
+
+			if ( map == null || map == Map.Internal )
+				return HousePlacementResult.BadLand; // A house cannot go here
+
+			if ( from.AccessLevel >= AccessLevel.GameMaster )
+				return HousePlacementResult.Valid; // Staff can place anywhere
+
+			if ( map == Map.Ilshenar || SpellHelper.IsFeluccaT2A( map, center ) )
+				return HousePlacementResult.BadRegion; // No houses in Ilshenar/T2A
+
+			if ( map == Map.Malas && ( multiID == 0x007C || multiID == 0x007E ) )
+				return HousePlacementResult.InvalidCastleKeep;
+
+			NoHousingRegion noHousingRegion = (NoHousingRegion) Region.Find( center, map ).GetRegion( typeof( NoHousingRegion ) );
+
+			if ( noHousingRegion != null )
+				return HousePlacementResult.BadRegion;
+
+			// This holds data describing the internal structure of the house
+			MultiComponentList mcl = MultiData.GetComponents( multiID );
+
+			if ( multiID >= 0x13EC && multiID < 0x1D00 )
+				HouseFoundation.AddStairsTo( ref mcl ); // this is a AOS house, add the stairs
+
+			// Location of the nortwest-most corner of the house
+			Point3D start = new Point3D( center.X + mcl.Min.X, center.Y + mcl.Min.Y, center.Z );
+
+			// These are storage lists. They hold items and mobiles found in the map for further processing
+			List<Item> items = new List<Item>();
+			List<Mobile> mobiles = new List<Mobile>();
+
+			// These are also storage lists. They hold location values indicating the yard and border locations.
+			List<Point2D> yard = new List<Point2D>(), borders = new List<Point2D>();
+
+			/* RULES:
+			 * 
+			 * 1) All tiles which are around the -outside- of the foundation must not have anything impassable.
+			 * 2) No impassable object or land tile may come in direct contact with any part of the house.
+			 * 3) Five tiles from the front and back of the house must be completely clear of all house tiles.
+			 * 4) The foundation must rest flatly on a surface. Any bumps around the foundation are not allowed.
+			 * 5) No foundation tile may reside over terrain which is viewed as a road.
+			 */
+
+			for ( int x = 0; x < mcl.Width; ++x )
+			{
+				for ( int y = 0; y < mcl.Height; ++y )
+				{
+					int tileX = start.X + x;
+					int tileY = start.Y + y;
+
+					StaticTile[] addTiles = mcl.Tiles[x][y];
+
+					if ( addTiles.Length == 0 )
+						continue; // There are no tiles here, continue checking somewhere else
+
+					Point3D testPoint = new Point3D( tileX, tileY, center.Z );
+
+					Region reg = Region.Find( testPoint, map );
+
+					if ( !reg.AllowHousing( from, testPoint ) ) // Cannot place houses in dungeons, towns, treasure map areas etc
+					{
+						if ( reg.IsPartOf( typeof( TempNoHousingRegion ) ) )
+							return HousePlacementResult.BadRegionTemp;
+
+						if ( reg.IsPartOf( typeof( TreasureRegion ) ) || reg.IsPartOf( typeof( HouseRegion ) ) )
+							return HousePlacementResult.BadRegionHidden;
+
+						if ( reg.IsPartOf( typeof( HouseRaffleRegion ) ) )
+							return HousePlacementResult.BadRegionRaffle;
+
+						return HousePlacementResult.BadRegion;
+					}
+
+					LandTile landTile = map.Tiles.GetLandTile( tileX, tileY );
+					int landID = landTile.ID & TileData.MaxLandValue;
+
+					StaticTile[] oldTiles = map.Tiles.GetStaticTiles( tileX, tileY, true );
+
+					Sector sector = map.GetSector( tileX, tileY );
+
+					items.Clear();
+
+					for ( int i = 0; i < sector.Items.Count; ++i )
+					{
+						Item item = sector.Items[i];
+
+						if ( item.Visible && item.X == tileX && item.Y == tileY )
+							items.Add( item );
+					}
+
+					mobiles.Clear();
+
+					for ( int i = 0; i < sector.Mobiles.Count; ++i )
+					{
+						Mobile m = sector.Mobiles[i];
+
+						if ( m.X == tileX && m.Y == tileY )
+							mobiles.Add( m );
+					}
+
+					int landStartZ = 0, landAvgZ = 0, landTopZ = 0;
+
+					map.GetAverageZ( tileX, tileY, ref landStartZ, ref landAvgZ, ref landTopZ );
+
+					bool hasFoundation = false;
+
+					for ( int i = 0; i < addTiles.Length; ++i )
+					{
+						StaticTile addTile = addTiles[i];
+
+						if ( addTile.ID == 0x1 ) // Nodraw
+							continue;
+
+						TileFlag addTileFlags = TileData.ItemTable[addTile.ID & TileData.MaxItemValue].Flags;
+
+						bool isFoundation = ( addTile.Z == 0 && (addTileFlags & TileFlag.Wall) != 0 );
+						bool hasSurface = false;
+
+						if ( isFoundation )
+							hasFoundation = true;
+
+						int addTileZ = center.Z + addTile.Z;
+						int addTileTop = addTileZ + addTile.Height;
+
+						if ( (addTileFlags & TileFlag.Surface) != 0 )
+							addTileTop += 16;
+
+						if ( addTileTop > landStartZ && landAvgZ > addTileZ )
+							return HousePlacementResult.BadLand; // Broke rule #2
+
+						if ( isFoundation && ((TileData.LandTable[landTile.ID & TileData.MaxLandValue].Flags & TileFlag.Impassable) == 0) && landAvgZ == center.Z )
+							hasSurface = true;
+
+						for ( int j = 0; j < oldTiles.Length; ++j )
+						{
+							StaticTile oldTile = oldTiles[j];
+							ItemData id = TileData.ItemTable[oldTile.ID & TileData.MaxItemValue];
+
+							if ( (id.Impassable || (id.Surface && (id.Flags & TileFlag.Background) == 0)) && addTileTop > oldTile.Z && (oldTile.Z + id.CalcHeight) > addTileZ )
+								return HousePlacementResult.BadStatic; // Broke rule #2
+							/*else if ( isFoundation && !hasSurface && (id.Flags & TileFlag.Surface) != 0 && (oldTile.Z + id.CalcHeight) == center.Z )
+								hasSurface = true;*/
+						}
+
+						for ( int j = 0; j < items.Count; ++j )
+						{
+							Item item = items[j];
+							ItemData id = item.ItemData;
+
+							if ( addTileTop > item.Z && (item.Z + id.CalcHeight) > addTileZ )
+							{
+								if ( item.Movable )
+									toMove.Add( item );
+								else if ( (id.Impassable || (id.Surface && (id.Flags & TileFlag.Background) == 0)) )
+									return HousePlacementResult.BadItem; // Broke rule #2
+							}
+							/*else if ( isFoundation && !hasSurface && (id.Flags & TileFlag.Surface) != 0 && (item.Z + id.CalcHeight) == center.Z )
+							{
+								hasSurface = true;
+							}*/
+						}
+
+						if ( isFoundation && !hasSurface )
+							return HousePlacementResult.NoSurface; // Broke rule #4
+
+						for ( int j = 0; j < mobiles.Count; ++j )
+						{
+							Mobile m = mobiles[j];
+
+							if ( addTileTop > m.Z && (m.Z + 16) > addTileZ )
+								toMove.Add( m );
+						}
+					}
+
+					for ( int i = 0; i < m_RoadIDs.Length; i += 2 )
+					{
+						if ( landID >= m_RoadIDs[i] && landID <= m_RoadIDs[i + 1] )
+							return HousePlacementResult.BadLand; // Broke rule #5
+					}
+
+					if ( hasFoundation )
+					{
+						for ( int xOffset = -1; xOffset <= 1; ++xOffset )
+						{
+							for ( int yOffset = -YardSize; yOffset <= YardSize; ++yOffset )
+							{
+								Point2D yardPoint = new Point2D( tileX + xOffset, tileY + yOffset );
+
+								if ( !yard.Contains( yardPoint ) )
+									yard.Add( yardPoint );
+							}
+						}
+
+						for ( int xOffset = -1; xOffset <= 1; ++xOffset )
+						{
+							for ( int yOffset = -1; yOffset <= 1; ++yOffset )
+							{
+								if ( xOffset == 0 && yOffset == 0 )
+									continue;
+
+								// To ease this rule, we will not add to the border list if the tile here is under a base floor (z<=8)
+
+								int vx = x + xOffset;
+								int vy = y + yOffset;
+
+								if ( vx >= 0 && vx < mcl.Width && vy >= 0 && vy < mcl.Height )
+								{
+									StaticTile[] breakTiles = mcl.Tiles[vx][vy];
+									bool shouldBreak = false;
+
+									for ( int i = 0; !shouldBreak && i < breakTiles.Length; ++i )
+									{
+										StaticTile breakTile = breakTiles[i];
+
+										if ( breakTile.Height == 0 && breakTile.Z <= 8 && TileData.ItemTable[breakTile.ID & TileData.MaxItemValue].Surface )
+											shouldBreak = true;
+									}
+
+									if ( shouldBreak )
+										continue;
+								}
+
+								Point2D borderPoint = new Point2D( tileX + xOffset, tileY + yOffset );
+
+								if ( !borders.Contains( borderPoint ) )
+									borders.Add( borderPoint );
+							}
+						}
+					}
+				}
+			}
+
+			for ( int i = 0; i < borders.Count; ++i )
+			{
+				Point2D borderPoint = borders[i];
+
+				LandTile landTile = map.Tiles.GetLandTile( borderPoint.X, borderPoint.Y );
+				int landID = landTile.ID & TileData.MaxLandValue;
+
+				if ( (TileData.LandTable[landID].Flags & TileFlag.Impassable) != 0 )
+					return HousePlacementResult.BadLand;
+
+				for ( int j = 0; j < m_RoadIDs.Length; j += 2 )
+				{
+					if ( landID >= m_RoadIDs[j] && landID <= m_RoadIDs[j + 1] )
+						return HousePlacementResult.BadLand; // Broke rule #5
+				}
+
+				StaticTile[] tiles = map.Tiles.GetStaticTiles( borderPoint.X, borderPoint.Y, true );
+
+				for ( int j = 0; j < tiles.Length; ++j )
+				{
+					StaticTile tile = tiles[j];
+					ItemData id = TileData.ItemTable[tile.ID & TileData.MaxItemValue];
+
+					if ( id.Impassable || (id.Surface && (id.Flags & TileFlag.Background) == 0 && (tile.Z + id.CalcHeight) > (center.Z + 2)) )
+						return HousePlacementResult.BadStatic; // Broke rule #1
+				}
+
+				Sector sector = map.GetSector( borderPoint.X, borderPoint.Y );
+				List<Item> sectorItems = sector.Items;
+
+				for ( int j = 0; j < sectorItems.Count; ++j )
+				{
+					Item item = sectorItems[j];
+
+					if ( item.X != borderPoint.X || item.Y != borderPoint.Y || item.Movable )
+						continue;
+
+					ItemData id = item.ItemData;
+
+					if ( id.Impassable || (id.Surface && (id.Flags & TileFlag.Background) == 0 && (item.Z + id.CalcHeight) > (center.Z + 2)) )
+						return HousePlacementResult.BadItem; // Broke rule #1
+				}
+			}
+
+			List<Sector> _sectors = new List<Sector>();
+			List<BaseHouse> _houses = new List<BaseHouse>();
+
+			for ( int i = 0; i < yard.Count; i++ ) {
+				Sector sector = map.GetSector( yard[i] );
+				
+				if ( !_sectors.Contains( sector ) ) {
+					_sectors.Add( sector );
+					
+					if ( sector.Multis != null ) {
+						for ( int j = 0; j < sector.Multis.Count; j++ ) {
+							if ( sector.Multis[j] is BaseHouse ) {
+								BaseHouse _house = (BaseHouse)sector.Multis[j];
+								if ( !_houses.Contains( _house ) ) {
+									_houses.Add( _house );
+								}
+							}
+						}
+					}
+				}
+			}
+
+			for ( int i = 0; i < yard.Count; ++i )
+			{
+				foreach ( BaseHouse b in _houses ) {
+					if ( b.Contains( yard[i] ) )
+						return HousePlacementResult.BadStatic; // Broke rule #3
+				}
+
+				/*Point2D yardPoint = yard[i];
+
+				IPooledEnumerable eable = map.GetMultiTilesAt( yardPoint.X, yardPoint.Y );
+
+				foreach ( StaticTile[] tile in eable )
+				{
+					for ( int j = 0; j < tile.Length; ++j )
+					{
+						if ( (TileData.ItemTable[tile[j].ID & TileData.MaxItemValue].Flags & (TileFlag.Impassable | TileFlag.Surface)) != 0 )
+						{
+							eable.Free();
+							return HousePlacementResult.BadStatic; // Broke rule #3
+						}
+					}
+				}
+
+				eable.Free();*/
+			}
+
+			return HousePlacementResult.Valid;
+		}
+	}
+}

Scripts/Multis/HousePlacementTool.cs

@@ -0,0 +1,794 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Gumps;
+using Server.Multis;
+using Server.Mobiles;
+using Server.Regions;
+using Server.Targeting;
+
+namespace Server.Items
+{
+	public class HousePlacementTool : Item
+	{
+		public override int LabelNumber{ get{ return 1060651; } } // a house placement tool
+
+		[Constructable]
+		public HousePlacementTool() : base( 0x14F6 )
+		{
+			Weight = 3.0;
+			LootType = LootType.Blessed;
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( IsChildOf( from.Backpack ) )
+				from.SendGump( new HousePlacementCategoryGump( from ) );
+			else
+				from.SendLocalizedMessage( 1042001 ); // That must be in your pack for you to use it.
+		}
+
+		public HousePlacementTool( 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();
+
+			if ( Weight == 0.0 )
+				Weight = 3.0;
+		}
+	}
+
+	public class HousePlacementCategoryGump : Gump
+	{
+		private Mobile m_From;
+
+		private const int LabelColor = 0x7FFF;
+		private const int LabelColorDisabled = 0x4210;
+
+		public HousePlacementCategoryGump( Mobile from ) : base( 50, 50 )
+		{
+			m_From = from;
+
+			from.CloseGump( typeof( HousePlacementCategoryGump ) );
+			from.CloseGump( typeof( HousePlacementListGump ) );
+
+			AddPage( 0 );
+
+			AddBackground( 0, 0, 270, 145, 5054 );
+
+			AddImageTiled( 10, 10, 250, 125, 2624 );
+			AddAlphaRegion( 10, 10, 250, 125 );
+
+			AddHtmlLocalized( 10, 10, 250, 20, 1060239, LabelColor, false, false ); // <CENTER>HOUSE PLACEMENT TOOL</CENTER>
+
+			AddButton( 10, 110, 4017, 4019, 0, GumpButtonType.Reply, 0 );
+			AddHtmlLocalized( 45, 110, 150, 20, 3000363, LabelColor, false, false ); // Close
+
+			AddButton( 10, 40, 4005, 4007, 1, GumpButtonType.Reply, 0 );
+			AddHtmlLocalized( 45, 40, 200, 20, 1060390, LabelColor, false, false ); // Classic Houses
+
+			AddButton( 10, 60, 4005, 4007, 2, GumpButtonType.Reply, 0 );
+			AddHtmlLocalized( 45, 60, 200, 20, 1060391, LabelColor, false, false ); // 2-Story Customizable Houses
+
+			AddButton( 10, 80, 4005, 4007, 3, GumpButtonType.Reply, 0 );
+			AddHtmlLocalized( 45, 80, 200, 20, 1060392, LabelColor, false, false ); // 3-Story Customizable Houses
+		}
+
+		public override void OnResponse( Server.Network.NetState sender, RelayInfo info )
+		{
+			if ( !m_From.CheckAlive() || m_From.Backpack == null || m_From.Backpack.FindItemByType( typeof( HousePlacementTool ) ) == null  )
+				return;
+
+			switch ( info.ButtonID )
+			{
+				case 1: // Classic Houses
+				{
+					m_From.SendGump( new HousePlacementListGump( m_From, HousePlacementEntry.ClassicHouses ) );
+					break;
+				}
+				case 2: // 2-Story Customizable Houses
+				{
+					m_From.SendGump( new HousePlacementListGump( m_From, HousePlacementEntry.TwoStoryFoundations ) );
+					break;
+				}
+				case 3: // 3-Story Customizable Houses
+				{
+					m_From.SendGump( new HousePlacementListGump( m_From, HousePlacementEntry.ThreeStoryFoundations ) );
+					break;
+				}
+			}
+		}
+	}
+
+	public class HousePlacementListGump : Gump
+	{
+		private Mobile m_From;
+		private HousePlacementEntry[] m_Entries;
+
+		private const int LabelColor = 0x7FFF;
+		private const int LabelHue = 0x480;
+
+		public HousePlacementListGump( Mobile from, HousePlacementEntry[] entries ) : base( 50, 50 )
+		{
+			m_From = from;
+			m_Entries = entries;
+
+			from.CloseGump( typeof( HousePlacementCategoryGump ) );
+			from.CloseGump( typeof( HousePlacementListGump ) );
+
+			AddPage( 0 );
+
+			AddBackground( 0, 0, 520, 420, 5054 );
+
+			AddImageTiled( 10, 10, 500, 20, 2624 );
+			AddAlphaRegion( 10, 10, 500, 20 );
+
+			AddHtmlLocalized( 10, 10, 500, 20, 1060239, LabelColor, false, false ); // <CENTER>HOUSE PLACEMENT TOOL</CENTER>
+
+			AddImageTiled( 10, 40, 500, 20, 2624 );
+			AddAlphaRegion( 10, 40, 500, 20 );
+
+			AddHtmlLocalized( 50, 40, 225, 20, 1060235, LabelColor, false, false ); // House Description
+			AddHtmlLocalized( 275, 40, 75, 20, 1060236, LabelColor, false, false ); // Storage
+			AddHtmlLocalized( 350, 40, 75, 20, 1060237, LabelColor, false, false ); // Lockdowns
+			AddHtmlLocalized( 425, 40, 75, 20, 1060034, LabelColor, false, false ); // Cost
+
+			AddImageTiled( 10, 70, 500, 280, 2624 );
+			AddAlphaRegion( 10, 70, 500, 280 );
+
+			AddImageTiled( 10, 360, 500, 20, 2624 );
+			AddAlphaRegion( 10, 360, 500, 20 );
+
+			AddHtmlLocalized( 10, 360, 250, 20, 1060645, LabelColor, false, false ); // Bank Balance:
+			AddLabel( 250, 360, LabelHue, Banker.GetBalance( from ).ToString() );
+
+			AddImageTiled( 10, 390, 500, 20, 2624 );
+			AddAlphaRegion( 10, 390, 500, 20 );
+
+			AddButton( 10, 390, 4017, 4019, 0, GumpButtonType.Reply, 0 );
+			AddHtmlLocalized( 50, 390, 100, 20, 3000363, LabelColor, false, false ); // Close
+
+			for ( int i = 0; i < entries.Length; ++i )
+			{
+				int page = 1 + (i / 14);
+				int index = i % 14;
+
+				if ( index == 0 )
+				{
+					if ( page > 1 )
+					{
+						AddButton( 450, 390, 4005, 4007, 0, GumpButtonType.Page, page );
+						AddHtmlLocalized( 400, 390, 100, 20, 3000406, LabelColor, false, false ); // Next
+					}
+
+					AddPage( page );
+
+					if ( page > 1 )
+					{
+						AddButton( 200, 390, 4014, 4016, 0, GumpButtonType.Page, page - 1 );
+						AddHtmlLocalized( 250, 390, 100, 20, 3000405, LabelColor, false, false ); // Previous
+					}
+				}
+
+				HousePlacementEntry entry = entries[i];
+
+				int y = 70 + (index * 20);
+
+				AddButton( 10, y, 4005, 4007, 1 + i, GumpButtonType.Reply, 0 );
+				AddHtmlLocalized( 50, y, 225, 20, entry.Description, LabelColor, false, false );
+				AddLabel( 275, y, LabelHue, entry.Storage.ToString() );
+				AddLabel( 350, y, LabelHue, entry.Lockdowns.ToString() );
+				AddLabel( 425, y, LabelHue, entry.Cost.ToString() );
+			}
+		}
+
+		public override void OnResponse( Server.Network.NetState sender, RelayInfo info )
+		{
+			if ( !m_From.CheckAlive() || m_From.Backpack == null || m_From.Backpack.FindItemByType( typeof( HousePlacementTool ) ) == null  )
+				return;
+
+			int index = info.ButtonID - 1;
+
+			if ( index >= 0 && index < m_Entries.Length )
+			{
+				if ( m_From.AccessLevel < AccessLevel.GameMaster && BaseHouse.HasAccountHouse( m_From ) )
+					m_From.SendLocalizedMessage( 501271 ); // You already own a house, you may not place another!
+				else
+					m_From.Target = new NewHousePlacementTarget( m_Entries, m_Entries[index] );
+			}
+			else
+			{
+				m_From.SendGump( new HousePlacementCategoryGump( m_From ) );
+			}
+		}
+	}
+
+	public class NewHousePlacementTarget : MultiTarget
+	{
+		private HousePlacementEntry m_Entry;
+		private HousePlacementEntry[] m_Entries;
+
+		private bool m_Placed;
+
+		public NewHousePlacementTarget( HousePlacementEntry[] entries, HousePlacementEntry entry ) : base( entry.MultiID, entry.Offset )
+		{
+			Range = 14;
+
+			m_Entries = entries;
+			m_Entry = entry;
+		}
+
+		protected override void OnTarget( Mobile from, object o )
+		{
+			if ( !from.CheckAlive() || from.Backpack == null || from.Backpack.FindItemByType( typeof( HousePlacementTool ) ) == null  )
+				return;
+
+			IPoint3D ip = o as IPoint3D;
+
+			if ( ip != null )
+			{
+				if ( ip is Item )
+					ip = ((Item)ip).GetWorldTop();
+
+				Point3D p = new Point3D( ip );
+
+				Region reg = Region.Find( new Point3D( p ), from.Map );
+
+				if ( from.AccessLevel >= AccessLevel.GameMaster || reg.AllowHousing( from, p ) )
+					m_Placed = m_Entry.OnPlacement( from, p );
+				else if ( reg.IsPartOf( typeof( TempNoHousingRegion ) ) )
+					from.SendLocalizedMessage( 501270 ); // Lord British has decreed a 'no build' period, thus you cannot build this house at this time.
+				else if ( reg.IsPartOf( typeof( TreasureRegion ) ) || reg.IsPartOf( typeof( HouseRegion ) ) )
+					from.SendLocalizedMessage( 1043287 ); // The house could not be created here.  Either something is blocking the house, or the house would not be on valid terrain.
+				else if ( reg.IsPartOf( typeof( HouseRaffleRegion ) ) )
+					from.SendLocalizedMessage( 1150493 ); // You must have a deed for this plot of land in order to build here.
+				else
+					from.SendLocalizedMessage( 501265 ); // Housing can not be created in this area.
+			}
+		}
+
+		protected override void OnTargetFinish( Mobile from )
+		{
+			if ( !from.CheckAlive() || from.Backpack == null || from.Backpack.FindItemByType( typeof( HousePlacementTool ) ) == null  )
+				return;
+
+			if ( !m_Placed )
+				from.SendGump( new HousePlacementListGump( from, m_Entries ) );
+		}
+	}
+
+	public class HousePlacementEntry
+	{
+		private Type m_Type;
+		private int m_Description;
+		private int m_Storage;
+		private int m_Lockdowns;
+		private int m_NewStorage;
+		private int m_NewLockdowns;
+		private int m_Vendors;
+		private int m_Cost;
+		private int m_MultiID;
+		private Point3D m_Offset;
+
+		public Type Type{ get{ return m_Type; } }
+
+		public int Description{ get{ return m_Description; } }
+		public int Storage{ get{ return BaseHouse.NewVendorSystem ? m_NewStorage : m_Storage; } }
+		public int Lockdowns{ get{ return BaseHouse.NewVendorSystem ? m_NewLockdowns : m_Lockdowns; } }
+		public int Vendors{ get{ return m_Vendors; } }
+		public int Cost{ get{ return m_Cost; } }
+
+		public int MultiID{ get{ return m_MultiID; } }
+		public Point3D Offset{ get{ return m_Offset; } }
+
+		public HousePlacementEntry( Type type, int description, int storage, int lockdowns, int newStorage, int newLockdowns, int vendors, int cost, int xOffset, int yOffset, int zOffset, int multiID )
+		{
+			m_Type = type;
+			m_Description = description;
+			m_Storage = storage;
+			m_Lockdowns = lockdowns;
+			m_NewStorage = newStorage;
+			m_NewLockdowns = newLockdowns;
+			m_Vendors = vendors;
+			m_Cost = cost;
+
+			m_Offset = new Point3D( xOffset, yOffset, zOffset );
+
+			m_MultiID = multiID;
+		}
+
+		public BaseHouse ConstructHouse( Mobile from )
+		{
+			try
+			{
+				object[] args;
+
+				if ( m_Type == typeof( HouseFoundation ) )
+					args = new object[4]{ from, m_MultiID, m_Storage, m_Lockdowns };
+				else if ( m_Type == typeof( SmallOldHouse ) || m_Type == typeof( SmallShop ) || m_Type == typeof( TwoStoryHouse ) )
+					args = new object[2]{ from, m_MultiID };
+				else
+					args = new object[1]{ from };
+
+				return Activator.CreateInstance( m_Type, args ) as BaseHouse;
+			}
+			catch
+			{
+			}
+
+			return null;
+		}
+
+		public void PlacementWarning_Callback( Mobile from, bool okay, object state )
+		{
+			if ( !from.CheckAlive() || from.Backpack == null || from.Backpack.FindItemByType( typeof( HousePlacementTool ) ) == null  )
+				return;
+
+			PreviewHouse prevHouse = (PreviewHouse)state;
+
+			if ( !okay )
+			{
+				prevHouse.Delete();
+				return;
+			}
+
+			if ( prevHouse.Deleted )
+			{
+				/* Too much time has passed and the test house you created has been deleted.
+				 * Please try again!
+				 */
+				from.SendGump( new NoticeGump( 1060637, 30720, 1060647, 32512, 320, 180, null, null ) );
+
+				return;
+			}
+
+			Point3D center = prevHouse.Location;
+			Map map = prevHouse.Map;
+
+			prevHouse.Delete();
+
+			ArrayList toMove;
+			//Point3D center = new Point3D( p.X - m_Offset.X, p.Y - m_Offset.Y, p.Z - m_Offset.Z );
+			HousePlacementResult res = HousePlacement.Check( from, m_MultiID, center, out toMove );
+
+			switch ( res )
+			{
+				case HousePlacementResult.Valid:
+				{
+					if ( from.AccessLevel < AccessLevel.GameMaster && BaseHouse.HasAccountHouse( from ) )
+					{
+						from.SendLocalizedMessage( 501271 ); // You already own a house, you may not place another!
+					}
+					else
+					{
+						BaseHouse house = ConstructHouse( from );
+
+						if ( house == null )
+							return;
+
+						house.Price = m_Cost;
+
+						if ( from.AccessLevel >= AccessLevel.GameMaster )
+						{
+							from.SendMessage( "{0} gold would have been withdrawn from your bank if you were not a GM.", m_Cost.ToString() );
+						}
+						else
+						{
+							if ( Banker.Withdraw( from, m_Cost ) )
+							{
+								from.SendLocalizedMessage( 1060398, m_Cost.ToString() ); // ~1_AMOUNT~ gold has been withdrawn from your bank box.
+							}
+							else
+							{
+								house.RemoveKeys( from );
+								house.Delete();
+								from.SendLocalizedMessage( 1060646 ); // You do not have the funds available in your bank box to purchase this house.  Try placing a smaller house, or adding gold or checks to your bank box.
+								return;
+							}
+						}
+
+						house.MoveToWorld( center, from.Map );
+
+						for ( int i = 0; i < toMove.Count; ++i )
+						{
+							object o = toMove[ i ];
+
+							if ( o is Mobile )
+								( (Mobile) o ).Location = house.BanLocation;
+							else if ( o is Item )
+								( (Item) o ).Location = house.BanLocation;
+						}
+					}
+
+					break;
+				}
+				case HousePlacementResult.BadItem:
+				case HousePlacementResult.BadLand:
+				case HousePlacementResult.BadStatic:
+				case HousePlacementResult.BadRegionHidden:
+				case HousePlacementResult.NoSurface:
+				{
+					from.SendLocalizedMessage( 1043287 ); // The house could not be created here.  Either something is blocking the house, or the house would not be on valid terrain.
+					break;
+				}
+				case HousePlacementResult.BadRegion:
+				{
+					from.SendLocalizedMessage( 501265 ); // Housing cannot be created in this area.
+					break;
+				}
+				case HousePlacementResult.BadRegionTemp:
+				{
+					from.SendLocalizedMessage( 501270 ); // Lord British has decreed a 'no build' period, thus you cannot build this house at this time.
+					break;
+				}
+				case HousePlacementResult.BadRegionRaffle:
+				{
+					from.SendLocalizedMessage( 1150493 ); // You must have a deed for this plot of land in order to build here.
+					break;
+				}
+				case HousePlacementResult.InvalidCastleKeep:
+				{
+					from.SendLocalizedMessage( 1061122 ); // Castles and keeps cannot be created here.
+					break;
+				}
+			}
+		}
+
+		public bool OnPlacement( Mobile from, Point3D p )
+		{
+			if ( !from.CheckAlive() || from.Backpack == null || from.Backpack.FindItemByType( typeof( HousePlacementTool ) ) == null  )
+				return false;
+
+			ArrayList toMove;
+			Point3D center = new Point3D( p.X - m_Offset.X, p.Y - m_Offset.Y, p.Z - m_Offset.Z );
+			HousePlacementResult res = HousePlacement.Check( from, m_MultiID, center, out toMove );
+
+			switch ( res )
+			{
+				case HousePlacementResult.Valid:
+				{
+					if ( from.AccessLevel < AccessLevel.GameMaster && BaseHouse.HasAccountHouse( from ) )
+					{
+						from.SendLocalizedMessage( 501271 ); // You already own a house, you may not place another!
+					}
+					else
+					{
+						from.SendLocalizedMessage( 1011576 ); // This is a valid location.
+
+						PreviewHouse prev = new PreviewHouse( m_MultiID );
+
+						MultiComponentList mcl = prev.Components;
+
+						Point3D banLoc = new Point3D( center.X + mcl.Min.X, center.Y + mcl.Max.Y + 1, center.Z );
+
+						for ( int i = 0; i < mcl.List.Length; ++i )
+						{
+							MultiTileEntry entry = mcl.List[i];
+
+							int itemID = entry.m_ItemID;
+
+							if ( itemID >= 0xBA3 && itemID <= 0xC0E )
+							{
+								banLoc = new Point3D( center.X + entry.m_OffsetX, center.Y + entry.m_OffsetY, center.Z );
+								break;
+							}
+						}
+
+						for ( int i = 0; i < toMove.Count; ++i )
+						{
+							object o = toMove[i];
+
+							if ( o is Mobile )
+								((Mobile)o).Location = banLoc;
+							else if ( o is Item )
+								((Item)o).Location = banLoc;
+						}
+
+						prev.MoveToWorld( center, from.Map );
+
+						/* You are about to place a new house.
+						 * Placing this house will condemn any and all of your other houses that you may have.
+						 * All of your houses on all shards will be affected.
+						 * 
+						 * In addition, you will not be able to place another house or have one transferred to you for one (1) real-life week.
+						 * 
+						 * Once you accept these terms, these effects cannot be reversed.
+						 * Re-deeding or transferring your new house will not uncondemn your other house(s) nor will the one week timer be removed.
+						 * 
+						 * If you are absolutely certain you wish to proceed, click the button next to OKAY below.
+						 * If you do not wish to trade for this house, click CANCEL.
+						 */
+						from.SendGump( new WarningGump( 1060635, 30720, 1049583, 32512, 420, 280, new WarningGumpCallback( PlacementWarning_Callback ), prev ) );
+
+						return true;
+					}
+
+					break;
+				}
+				case HousePlacementResult.BadItem:
+				case HousePlacementResult.BadLand:
+				case HousePlacementResult.BadStatic:
+				case HousePlacementResult.BadRegionHidden:
+				case HousePlacementResult.NoSurface:
+				{
+					from.SendLocalizedMessage( 1043287 ); // The house could not be created here.  Either something is blocking the house, or the house would not be on valid terrain.
+					break;
+				}
+				case HousePlacementResult.BadRegion:
+				{
+					from.SendLocalizedMessage( 501265 ); // Housing cannot be created in this area.
+					break;
+				}
+				case HousePlacementResult.BadRegionTemp:
+				{
+					from.SendLocalizedMessage( 501270 ); //Lord British has decreed a 'no build' period, thus you cannot build this house at this time.
+					break;
+				}
+				case HousePlacementResult.BadRegionRaffle:
+				{
+					from.SendLocalizedMessage( 1150493 ); // You must have a deed for this plot of land in order to build here.
+					break;
+				}
+				case HousePlacementResult.InvalidCastleKeep:
+				{
+					from.SendLocalizedMessage( 1061122 ); // Castles and keeps cannot be created here.
+					break;
+				}
+			}
+
+			return false;
+		}
+
+		private static Hashtable m_Table;
+
+		static HousePlacementEntry()
+		{
+			m_Table = new Hashtable();
+
+			FillTable( m_ClassicHouses );
+			FillTable( m_TwoStoryFoundations );
+			FillTable( m_ThreeStoryFoundations );
+		}
+
+		public static HousePlacementEntry Find( BaseHouse house )
+		{
+			object obj = m_Table[house.GetType()];
+
+			if ( obj is HousePlacementEntry )
+			{
+				return ((HousePlacementEntry)obj);
+			}
+			else if ( obj is ArrayList )
+			{
+				ArrayList list = (ArrayList)obj;
+
+				for ( int i = 0; i < list.Count; ++i )
+				{
+					HousePlacementEntry e = (HousePlacementEntry)list[i];
+
+					if ( e.m_MultiID == house.ItemID )
+						return e;
+				}
+			}
+			else if ( obj is Hashtable )
+			{
+				Hashtable table = (Hashtable)obj;
+
+				obj = table[house.ItemID];
+
+				if ( obj is HousePlacementEntry )
+					return (HousePlacementEntry)obj;
+			}
+
+			return null;
+		}
+
+		private static void FillTable( HousePlacementEntry[] entries )
+		{
+			for ( int i = 0; i < entries.Length; ++i )
+			{
+				HousePlacementEntry e = entries[i];
+
+				object obj = m_Table[e.m_Type];
+
+				if ( obj == null )
+				{
+					m_Table[e.m_Type] = e;
+				}
+				else if ( obj is HousePlacementEntry )
+				{
+					ArrayList list = new ArrayList();
+
+					list.Add( obj );
+					list.Add( e );
+
+					m_Table[e.m_Type] = list;
+				}
+				else if ( obj is ArrayList )
+				{
+					ArrayList list = (ArrayList)obj;
+
+					if ( list.Count == 8 )
+					{
+						Hashtable table = new Hashtable();
+
+						for ( int j = 0; j < list.Count; ++j )
+							table[((HousePlacementEntry)list[j]).m_MultiID] = list[j];
+
+						table[e.m_MultiID] = e;
+
+						m_Table[e.m_Type] = table;
+					}
+					else
+					{
+						list.Add( e );
+					}
+				}
+				else if ( obj is Hashtable )
+				{
+					((Hashtable)obj)[e.m_MultiID] = e;
+				}
+			}
+		}
+
+		private static HousePlacementEntry[] m_ClassicHouses = new HousePlacementEntry[]
+			{
+				new HousePlacementEntry( typeof( SmallOldHouse ),		1011303,	425,	212,	489,	244,	10,	37000,		0,	4,	0,	0x0064	),
+				new HousePlacementEntry( typeof( SmallOldHouse ),		1011304,	425,	212,	489,	244,	10,	37000,		0,	4,	0,	0x0066	),
+				new HousePlacementEntry( typeof( SmallOldHouse ),		1011305,	425,	212,	489,	244,	10,	36750,		0,	4,	0,	0x0068	),
+				new HousePlacementEntry( typeof( SmallOldHouse ),		1011306,	425,	212,	489,	244,	10,	35250,		0,	4,	0,	0x006A	),
+				new HousePlacementEntry( typeof( SmallOldHouse ),		1011307,	425,	212,	489,	244,	10,	36750,		0,	4,	0,	0x006C	),
+				new HousePlacementEntry( typeof( SmallOldHouse ),		1011308,	425,	212,	489,	244,	10,	36750,		0,	4,	0,	0x006E	),
+				new HousePlacementEntry( typeof( SmallShop ),			1011321,	425,	212,	489,	244,	10,	50500,	   -1,	4,	0,	0x00A0	),
+				new HousePlacementEntry( typeof( SmallShop ),			1011322,	425,	212,	489,	244,	10,	52500,		0,	4,	0,	0x00A2	),
+				new HousePlacementEntry( typeof( SmallTower ),			1011317,	580,	290,	667,	333,	14,	73500,		3,	4,	0,	0x0098	),
+				new HousePlacementEntry( typeof( TwoStoryVilla ),		1011319,	1100,	550,	1265,	632,	24,	113750,		3,	6,	0,	0x009E	),
+				new HousePlacementEntry( typeof( SandStonePatio ),		1011320,	850,	425,	1265,	632,	24,	76500,	   -1,	4,	0,	0x009C	),
+				new HousePlacementEntry( typeof( LogCabin ),			1011318,	1100,	550,	1265,	632,	24,	81750,		1,	6,	0,	0x009A	),
+				new HousePlacementEntry( typeof( GuildHouse ),			1011309,	1370,	685,	1576,	788,	28,	131500,	   -1,	7,	0,	0x0074	),
+				new HousePlacementEntry( typeof( TwoStoryHouse ),		1011310,	1370,	685,	1576,	788,	28,	162750,	   -3,	7,	0,	0x0076	),
+				new HousePlacementEntry( typeof( TwoStoryHouse ),		1011311,	1370,	685,	1576,	788,	28,	162000,	   -3,	7,	0,	0x0078	),
+				new HousePlacementEntry( typeof( LargePatioHouse ),		1011315,	1370,	685,	1576,	788,	28,	129250,	   -4,	7,	0,	0x008C	),
+				new HousePlacementEntry( typeof( LargeMarbleHouse ),	1011316,	1370,	685,	1576,	788,	28,	160500,	   -4,	7,	0,	0x0096	),
+				new HousePlacementEntry( typeof( Tower ),				1011312,	2119,	1059,	2437,	1218,	42,	366500,		0,	7,	0,	0x007A	),
+				new HousePlacementEntry( typeof( Keep ),				1011313,	2625,	1312,	3019,	1509,	52,	572750,		0, 11,	0,	0x007C	),
+				new HousePlacementEntry( typeof( Castle ),				1011314,	4076,	2038,	4688,	2344,	78,	865250,		0, 16,	0,	0x007E	)
+			};
+
+		public static HousePlacementEntry[] ClassicHouses{ get{ return m_ClassicHouses; } }
+
+
+
+
+
+		private static HousePlacementEntry[] m_TwoStoryFoundations = new HousePlacementEntry[]
+			{
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060241,	425,	212,	489,	244,	10,	30500,		0,	4,	0,	0x13EC	), // 7x7 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060242,	580,	290,	667,	333,	14,	34500,		0,	5,	0,	0x13ED	), // 7x8 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060243,	650,	325,	748,	374,	16,	38500,		0,	5,	0,	0x13EE	), // 7x9 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060244,	700,	350,	805,	402,	16,	42500,		0,	6,	0,	0x13EF	), // 7x10 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060245,	750,	375,	863,	431,	16,	46500,		0,	6,	0,	0x13F0	), // 7x11 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060246,	800,	400,	920,	460,	18,	50500,		0,	7,	0,	0x13F1	), // 7x12 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060253,	580,	290,	667,	333,	14,	34500,		0,	4,	0,	0x13F8	), // 8x7 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060254,	650,	325,	748,	374,	16,	39000,		0,	5,	0,	0x13F9	), // 8x8 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060255,	700,	350,	805,	402,	16,	43500,		0,	5,	0,	0x13FA	), // 8x9 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060256,	750,	375,	863,	431,	16,	48000,		0,	6,	0,	0x13FB	), // 8x10 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060257,	800,	400,	920,	460,	18,	52500,		0,	6,	0,	0x13FC	), // 8x11 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060258,	850,	425,	1265,	632,	24,	57000,		0,	7,	0,	0x13FD	), // 8x12 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060259,	1100,	550,	1265,	632,	24,	61500,		0,	7,	0,	0x13FE	), // 8x13 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060265,	650,	325,	748,	374,	16,	38500,		0,	4,	0,	0x1404	), // 9x7 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060266,	700,	350,	805,	402,	16,	43500,		0,	5,	0,	0x1405	), // 9x8 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060267,	750,	375,	863,	431,	16,	48500,		0,	5,	0,	0x1406	), // 9x9 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060268,	800,	400,	920,	460,	18,	53500,		0,	6,	0,	0x1407	), // 9x10 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060269,	850,	425,	1265,	632,	24,	58500,		0,	6,	0,	0x1408	), // 9x11 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060270,	1100,	550,	1265,	632,	24,	63500,		0,	7,	0,	0x1409	), // 9x12 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060271,	1100,	550,	1265,	632,	24,	68500,		0,	7,	0,	0x140A	), // 9x13 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060277,	700,	350,	805,	402,	16,	42500,		0,	4,	0,	0x1410	), // 10x7 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060278,	750,	375,	863,	431,	16,	48000,		0,	5,	0,	0x1411	), // 10x8 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060279,	800,	400,	920,	460,	18,	53500,		0,	5,	0,	0x1412	), // 10x9 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060280,	850,	425,	1265,	632,	24,	59000,		0,	6,	0,	0x1413	), // 10x10 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060281,	1100,	550,	1265,	632,	24,	64500,		0,	6,	0,	0x1414	), // 10x11 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060282,	1100,	550,	1265,	632,	24,	70000,		0,	7,	0,	0x1415	), // 10x12 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060283,	1150,	575,	1323,	661,	24,	75500,		0,	7,	0,	0x1416	), // 10x13 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060289,	750,	375,	863,	431,	16,	46500,		0,	4,	0,	0x141C	), // 11x7 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060290,	800,	400,	920,	460,	18,	52500,		0,	5,	0,	0x141D	), // 11x8 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060291,	850,	425,	1265,	632,	24,	58500,		0,	5,	0,	0x141E	), // 11x9 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060292,	1100,	550,	1265,	632,	24,	64500,		0,	6,	0,	0x141F	), // 11x10 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060293,	1100,	550,	1265,	632,	24,	70500,		0,	6,	0,	0x1420	), // 11x11 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060294,	1150,	575,	1323,	661,	24,	76500,		0,	7,	0,	0x1421	), // 11x12 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060295,	1200,	600,	1380,	690,	26,	82500,		0,	7,	0,	0x1422	), // 11x13 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060301,	800,	400,	920,	460,	18,	50500,		0,	4,	0,	0x1428	), // 12x7 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060302,	850,	425,	1265,	632,	24,	57000,		0,	5,	0,	0x1429	), // 12x8 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060303,	1100,	550,	1265,	632,	24,	63500,		0,	5,	0,	0x142A	), // 12x9 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060304,	1100,	550,	1265,	632,	24,	70000,		0,	6,	0,	0x142B	), // 12x10 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060305,	1150,	575,	1323,	661,	24,	76500,		0,	6,	0,	0x142C	), // 12x11 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060306,	1200,	600,	1380,	690,	26,	83000,		0,	7,	0,	0x142D	), // 12x12 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060307,	1250,	625,	1438,	719,	26,	89500,		0,	7,	0,	0x142E	), // 12x13 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060314,	1100,	550,	1265,	632,	24,	61500,		0,	5,	0,	0x1435	), // 13x8 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060315,	1100,	550,	1265,	632,	24,	68500,		0,	5,	0,	0x1436	), // 13x9 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060316,	1150,	575,	1323,	661,	24,	75500,		0,	6,	0,	0x1437	), // 13x10 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060317,	1200,	600,	1380,	690,	26,	82500,		0,	6,	0,	0x1438	), // 13x11 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060318,	1250,	625,	1438,	719,	26,	89500,		0,	7,	0,	0x1439	), // 13x12 2-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060319,	1300,	650,	1495,	747,	28,	96500,		0,	7,	0,	0x143A	)  // 13x13 2-Story Customizable House
+			};
+
+		public static HousePlacementEntry[] TwoStoryFoundations{ get{ return m_TwoStoryFoundations; } }
+
+
+
+
+
+		private static HousePlacementEntry[] m_ThreeStoryFoundations = new HousePlacementEntry[]
+			{
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060272,	1150,	575,	1323,	661,	24,	73500,		0,	8,	0,	0x140B	), // 9x14 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060284,	1200,	600,	1380,	690,	26,	81000,		0,	8,	0,	0x1417	), // 10x14 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060285,	1250,	625,	1438,	719,	26,	86500,		0,	8,	0,	0x1418	), // 10x15 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060296,	1250,	625,	1438,	719,	26,	88500,		0,	8,	0,	0x1423	), // 11x14 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060297,	1300,	650,	1495,	747,	28,	94500,		0,	8,	0,	0x1424	), // 11x15 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060298,	1350,	675,	1553,	776,	28,	100500,		0,	9,	0,	0x1425	), // 11x16 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060308,	1300,	650,	1495,	747,	28,	96000,		0,	8,	0,	0x142F	), // 12x14 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060309,	1350,	675,	1553,	776,	28,	102500,		0,	8,	0,	0x1430	), // 12x15 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060310,	1370,	685,	1576,	788,	28,	109000,		0,	9,	0,	0x1431	), // 12x16 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060311,	1370,	685,	1576,	788,	28,	115500,		0,	9,	0,	0x1432	), // 12x17 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060320,	1350,	675,	1553,	776,	28,	103500,		0,	8,	0,	0x143B	), // 13x14 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060321,	1370,	685,	1576,	788,	28,	110500,		0,	8,	0,	0x143C	), // 13x15 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060322,	1370,	685,	1576,	788,	28,	117500,		0,	9,	0,	0x143D	), // 13x16 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060323,	2119,	1059,	2437,	1218,	42,	124500,		0,	9,	0,	0x143E	), // 13x17 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060324,	2119,	1059,	2437,	1218,	42,	131500,		0,	10,	0,	0x143F	), // 13x18 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060327,	1150,	575,	1323,	661,	24,	73500,		0,	5,	0,	0x1442	), // 14x9 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060328,	1200,	600,	1380,	690,	26,	81000,		0,	6,	0,	0x1443	), // 14x10 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060329,	1250,	625,	1438,	719,	26,	88500,		0,	6,	0,	0x1444	), // 14x11 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060330,	1300,	650,	1495,	747,	28,	96000,		0,	7,	0,	0x1445	), // 14x12 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060331,	1350,	675,	1553,	776,	28,	103500,		0,	7,	0,	0x1446	), // 14x13 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060332,	1370,	685,	1576,	788,	28,	111000,		0,	8,	0,	0x1447	), // 14x14 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060333,	1370,	685,	1576,	788,	28,	118500,		0,	8,	0,	0x1448	), // 14x15 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060334,	2119,	1059,	2437,	1218,	42,	126000,		0,	9,	0,	0x1449	), // 14x16 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060335,	2119,	1059,	2437,	1218,	42,	133500,		0,	9,	0,	0x144A	), // 14x17 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060336,	2119,	1059,	2437,	1218,	42,	141000,		0,	10,	0,	0x144B	), // 14x18 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060340,	1250,	625,	1438,	719,	26,	86500,		0,	6,	0,	0x144F	), // 15x10 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060341,	1300,	650,	1495,	747,	28,	94500,		0,	6,	0,	0x1450	), // 15x11 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060342,	1350,	675,	1553,	776,	28,	102500,		0,	7,	0,	0x1451	), // 15x12 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060343,	1370,	685,	1576,	788,	28,	110500,		0,	7,	0,	0x1452	), // 15x13 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060344,	1370,	685,	1576,	788,	28,	118500,		0,	8,	0,	0x1453	), // 15x14 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060345,	2119,	1059,	2437,	1218,	42,	126500,		0,	8,	0,	0x1454	), // 15x15 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060346,	2119,	1059,	2437,	1218,	42,	134500,		0,	9,	0,	0x1455	), // 15x16 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060347,	2119,	1059,	2437,	1218,	42,	142500,		0,	9,	0,	0x1456	), // 15x17 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060348,	2119,	1059,	2437,	1218,	42,	150500,		0,	10,	0,	0x1457	), // 15x18 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060353,	1350,	675,	1553,	776,	28,	100500,		0,	6,	0,	0x145C	), // 16x11 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060354,	1370,	685,	1576,	788,	28,	109000,		0,	7,	0,	0x145D	), // 16x12 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060355,	1370,	685,	1576,	788,	28,	117500,		0,	7,	0,	0x145E	), // 16x13 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060356,	2119,	1059,	2437,	1218,	42,	126000,		0,	8,	0,	0x145F	), // 16x14 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060357,	2119,	1059,	2437,	1218,	42,	134500,		0,	8,	0,	0x1460	), // 16x15 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060358,	2119,	1059,	2437,	1218,	42,	143000,		0,	9,	0,	0x1461	), // 16x16 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060359,	2119,	1059,	2437,	1218,	42,	151500,		0,	9,	0,	0x1462	), // 16x17 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060360,	2119,	1059,	2437,	1218,	42,	160000,		0,	10,	0,	0x1463	), // 16x18 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060366,	1370,	685,	1576,	788,	28,	115500,		0,	7,	0,	0x1469	), // 17x12 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060367,	2119,	1059,	2437,	1218,	42,	124500,		0,	7,	0,	0x146A	), // 17x13 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060368,	2119,	1059,	2437,	1218,	42,	133500,		0,	8,	0,	0x146B	), // 17x14 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060369,	2119,	1059,	2437,	1218,	42,	142500,		0,	8,	0,	0x146C	), // 17x15 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060370,	2119,	1059,	2437,	1218,	42,	151500,		0,	9,	0,	0x146D	), // 17x16 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060371,	2119,	1059,	2437,	1218,	42,	160500,		0,	9,	0,	0x146E	), // 17x17 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060372,	2119,	1059,	2437,	1218,	42,	169500,		0,	10,	0,	0x146F	), // 17x18 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060379,	2119,	1059,	2437,	1218,	42,	131500,		0,	7,	0,	0x1476	), // 18x13 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060380,	2119,	1059,	2437,	1218,	42,	141000,		0,	8,	0,	0x1477	), // 18x14 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060381,	2119,	1059,	2437,	1218,	42,	150500,		0,	8,	0,	0x1478	), // 18x15 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060382,	2119,	1059,	2437,	1218,	42,	160000,		0,	9,	0,	0x1479	), // 18x16 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060383,	2119,	1059,	2437,	1218,	42,	169500,		0,	9,	0,	0x147A	), // 18x17 3-Story Customizable House
+				new HousePlacementEntry( typeof( HouseFoundation ),		1060384,	2119,	1059,	2437,	1218,	42,	179000,		0,	10,	0,	0x147B	)  // 18x18 3-Story Customizable House
+			};
+
+		public static HousePlacementEntry[] ThreeStoryFoundations{ get{ return m_ThreeStoryFoundations; } }
+	}
+}

Scripts/Multis/HouseSign.cs

@@ -0,0 +1,306 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server;
+using Server.Multis;
+using Server.Gumps;
+using Server.ContextMenus;
+
+namespace Server.Multis
+{
+	public class HouseSign : Item
+	{
+		private BaseHouse m_Owner;
+		private Mobile m_OrgOwner;
+
+		public HouseSign( BaseHouse owner ) : base( 0xBD2 )
+		{
+			m_Owner = owner;
+			m_OrgOwner = m_Owner.Owner;
+			Movable = false;
+		}
+
+		public HouseSign( Serial serial ) : base( serial )
+		{
+		}
+
+		public string GetName()
+		{
+			if ( Name == null )
+				return "An Unnamed House";
+
+			return Name;
+		}
+
+		public BaseHouse Owner
+		{
+			get
+			{
+				return m_Owner;
+			}
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public bool RestrictDecay
+		{
+			get{ return ( m_Owner != null && m_Owner.RestrictDecay ); }
+			set{ if ( m_Owner != null ) m_Owner.RestrictDecay = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public Mobile OriginalOwner
+		{
+			get
+			{
+				return m_OrgOwner;
+			}
+		}
+
+		public override void OnAfterDelete()
+		{
+			base.OnAfterDelete();
+
+			if ( m_Owner != null && !m_Owner.Deleted )
+				m_Owner.Delete();
+		}
+
+		public override void AddNameProperty(ObjectPropertyList list)
+		{
+			list.Add( 1061638 ); // A House Sign
+		}
+
+		public override bool ForceShowProperties{ get{ return ObjectPropertyList.Enabled; } }
+
+		private bool m_GettingProperties;
+
+		public bool GettingProperties
+		{
+			get { return m_GettingProperties; }
+		}
+
+		public override void GetProperties( ObjectPropertyList list )
+		{
+			base.GetProperties( list );
+
+			list.Add( 1061639, Utility.FixHtml( GetName() ) ); // Name: ~1_NAME~
+			list.Add( 1061640, (m_Owner == null || m_Owner.Owner == null) ? "nobody" : m_Owner.Owner.Name ); // Owner: ~1_OWNER~
+
+			if ( m_Owner != null )
+			{
+				list.Add( m_Owner.Public ? 1061641 : 1061642 ); // This House is Open to the Public : This is a Private Home
+
+				m_GettingProperties = true;
+				DecayLevel level = m_Owner.DecayLevel;
+				m_GettingProperties = false;
+
+				if ( level == DecayLevel.DemolitionPending )
+				{
+					list.Add( 1062497 ); // Demolition Pending
+				}
+				else if ( level != DecayLevel.Ageless )
+				{
+					if ( level == DecayLevel.Collapsed )
+						level = DecayLevel.IDOC;
+
+					list.Add( 1062028, String.Format( "#{0}", 1043009 + (int)level ) ); // Condition: This structure is ...
+				}
+			}
+		}
+
+		public override void OnSingleClick( Mobile from )
+		{
+			if ( m_Owner != null && BaseHouse.DecayEnabled && m_Owner.DecayPeriod != TimeSpan.Zero )
+			{
+				string message;
+
+				switch ( m_Owner.DecayLevel )
+				{
+					case DecayLevel.Ageless:	message = "ageless"; break;
+					case DecayLevel.Fairly:		message = "fairly worn"; break;
+					case DecayLevel.Greatly:	message = "greatly worn"; break;
+					case DecayLevel.LikeNew:	message = "like new"; break;
+					case DecayLevel.Slightly:	message = "slightly worn"; break;
+					case DecayLevel.Somewhat:	message = "somewhat worn"; break;
+					default:					message = "in danger of collapsing"; break;
+				}
+
+				LabelTo( from, "This house is {0}.", message );
+			}
+
+			base.OnSingleClick( from );
+		}
+
+		public void ShowSign( Mobile m )
+		{
+			if ( m_Owner != null )
+			{
+				if ( m_Owner.IsFriend( m ) && m.AccessLevel < AccessLevel.GameMaster )
+				{
+					#region Mondain's Legacy
+					if ( ( Core.ML && m_Owner.IsOwner( m ) ) || !Core.ML )
+						m_Owner.RefreshDecay();
+					#endregion
+					if ( !Core.AOS )
+						m.SendLocalizedMessage( 501293 ); // Welcome back to the house, friend!
+				}
+
+				if ( m_Owner.IsAosRules )
+					m.SendGump( new HouseGumpAOS( HouseGumpPageAOS.Information, m, m_Owner ) );
+				else
+					m.SendGump( new HouseGump( m, m_Owner ) );
+			}
+		}
+
+		public void ClaimGump_Callback( Mobile from, bool okay, object state )
+		{
+			if ( okay && m_Owner != null && m_Owner.Owner == null && m_Owner.DecayLevel != DecayLevel.DemolitionPending )
+			{
+				bool canClaim = false;
+
+				if ( m_Owner.CoOwners == null || m_Owner.CoOwners.Count == 0 )
+					canClaim = m_Owner.IsFriend( from );
+				else
+					canClaim = m_Owner.IsCoOwner( from );
+
+				if ( canClaim && !BaseHouse.HasAccountHouse( from ) )
+				{
+					m_Owner.Owner = from;
+					m_Owner.LastTraded = DateTime.UtcNow;
+				}
+			}
+
+			ShowSign( from );
+		}
+
+		public override void OnDoubleClick( Mobile m )
+		{
+			if ( m_Owner == null )
+				return;
+
+			if ( m.AccessLevel < AccessLevel.GameMaster && m_Owner.Owner == null && m_Owner.DecayLevel != DecayLevel.DemolitionPending )
+			{
+				bool canClaim = false;
+
+				if ( m_Owner.CoOwners == null || m_Owner.CoOwners.Count == 0 )
+					canClaim = m_Owner.IsFriend( m );
+				else
+					canClaim = m_Owner.IsCoOwner( m );
+
+				if ( canClaim && !BaseHouse.HasAccountHouse( m ) )
+				{
+					/* You do not currently own any house on any shard with this account,
+					 * and this house currently does not have an owner.  If you wish, you
+					 * may choose to claim this house and become its rightful owner.  If
+					 * you do this, it will become your Primary house and automatically
+					 * refresh.  If you claim this house, you will be unable to place
+					 * another house or have another house transferred to you for the
+					 * next 7 days.  Do you wish to claim this house?
+					 */
+					m.SendGump( new WarningGump( 501036, 32512, 1049719, 32512, 420, 280, new WarningGumpCallback( ClaimGump_Callback ), null ) );
+				}
+			}
+
+			ShowSign( m );
+		}
+
+		public override void GetContextMenuEntries( Mobile from, List<ContextMenuEntry> list )
+		{
+			base.GetContextMenuEntries( from, list );
+
+			if ( BaseHouse.NewVendorSystem && from.Alive && Owner != null && Owner.IsAosRules )
+			{
+				if ( Owner.AreThereAvailableVendorsFor( from ) )
+					list.Add( new VendorsEntry( this ) );
+
+				if ( Owner.VendorInventories.Count > 0 )
+					list.Add( new ReclaimVendorInventoryEntry( this ) );
+			}
+		}
+
+		private class VendorsEntry : ContextMenuEntry
+		{
+			private HouseSign m_Sign;
+
+			public VendorsEntry( HouseSign sign ) : base( 6211 )
+			{
+				m_Sign = sign;
+			}
+
+			public override void OnClick()
+			{
+				Mobile from = this.Owner.From;
+
+				if ( !from.CheckAlive() || m_Sign.Deleted || m_Sign.Owner == null || !m_Sign.Owner.AreThereAvailableVendorsFor( from ) )
+					return;
+
+				if ( from.Map != m_Sign.Map || !from.InRange( m_Sign, 5 ) )
+				{
+					from.SendLocalizedMessage( 1062429 ); // You must be within five paces of the house sign to use this option.
+				}
+				else
+				{
+					from.SendGump( new HouseGumpAOS( HouseGumpPageAOS.Vendors, from, m_Sign.Owner ) );
+				}
+			}
+		}
+
+		private class ReclaimVendorInventoryEntry : ContextMenuEntry
+		{
+			private HouseSign m_Sign;
+
+			public ReclaimVendorInventoryEntry( HouseSign sign ) : base( 6213 )
+			{
+				m_Sign = sign;
+			}
+
+			public override void OnClick()
+			{
+				Mobile from = this.Owner.From;
+
+				if ( m_Sign.Deleted || m_Sign.Owner == null || m_Sign.Owner.VendorInventories.Count == 0 || !from.CheckAlive() )
+					return;
+
+				if ( from.Map != m_Sign.Map || !from.InRange( m_Sign, 5 ) )
+				{
+					from.SendLocalizedMessage( 1062429 ); // You must be within five paces of the house sign to use this option.
+				}
+				else
+				{
+					from.CloseGump( typeof( VendorInventoryGump ) );
+					from.SendGump( new VendorInventoryGump( m_Sign.Owner, from ) );
+				}
+			}
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+
+			writer.Write( m_Owner );
+			writer.Write( m_OrgOwner );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 0:
+				{
+					m_Owner = reader.ReadItem() as BaseHouse;
+					m_OrgOwner = reader.ReadMobile();
+
+					break;
+				}
+			}
+
+			if ( this.Name == "a house sign" )
+				this.Name = null;
+		}
+	}
+}

Scripts/Multis/HouseTeleporter.cs

@@ -0,0 +1,187 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Gumps;
+using Server.Multis;
+using Server.Targeting;
+using System.Collections.Generic;
+using Server.ContextMenus;
+
+namespace Server.Items
+{
+	public class HouseTeleporter : Item, ISecurable
+	{
+		private Item m_Target;
+		private SecureLevel m_Level;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public Item Target
+		{
+			get{ return m_Target; }
+			set{ m_Target = value; }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public SecureLevel Level
+		{
+			get{ return m_Level; }
+			set{ m_Level = value; }
+		}
+
+		[Constructable]
+		public HouseTeleporter( int itemID ) : this( itemID, null )
+		{
+		}
+
+		public HouseTeleporter( int itemID, Item target ) : base( itemID )
+		{
+			Movable = false;
+
+			m_Level = SecureLevel.Anyone;
+
+			m_Target = target;
+		}
+
+		public bool CheckAccess( Mobile m )
+		{
+			BaseHouse house = BaseHouse.FindHouseAt( this );
+
+			if ( house != null && (house.Public ? house.IsBanned( m ) : !house.HasAccess( m )) )
+				return false;
+
+			return ( house != null && house.HasSecureAccess( m, m_Level ) );
+		}
+
+		public override bool OnMoveOver( Mobile m )
+		{
+			if ( m_Target != null && !m_Target.Deleted )
+			{
+				if ( CheckAccess( m ) )
+				{
+					if ( !m.Hidden || m.AccessLevel == AccessLevel.Player )
+						new EffectTimer( Location, Map, 2023, 0x1F0, TimeSpan.FromSeconds( 0.4 ) ).Start();
+
+					new DelayTimer( this, m ).Start();
+				}
+				else
+				{
+					m.SendLocalizedMessage( 1061637 ); // You are not allowed to access this.
+				}
+			}
+
+			return true;
+		}
+
+		public override void GetContextMenuEntries( Mobile from, List<ContextMenuEntry> list )
+		{
+			base.GetContextMenuEntries( from, list );
+			SetSecureLevelEntry.AddTo( from, this, list );
+		}
+
+		public HouseTeleporter( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 1 ); // version
+
+			writer.Write( (int) m_Level );
+
+			writer.Write( (Item) m_Target );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 1:
+				{
+					m_Level = (SecureLevel)reader.ReadInt();
+					goto case 0;
+				}
+				case 0:
+				{
+					m_Target = reader.ReadItem();
+
+					if ( version < 0 )
+						m_Level = SecureLevel.Anyone;
+
+					break;
+				}
+			}
+		}
+
+		private class EffectTimer : Timer
+		{
+			private Point3D m_Location;
+			private Map m_Map;
+			private int m_EffectID;
+			private int m_SoundID;
+
+			public EffectTimer( Point3D p, Map map, int effectID, int soundID, TimeSpan delay ) : base( delay )
+			{
+				m_Location = p;
+				m_Map = map;
+				m_EffectID = effectID;
+				m_SoundID = soundID;
+			}
+
+			protected override void OnTick()
+			{
+				Effects.SendLocationParticles( EffectItem.Create( m_Location, m_Map, EffectItem.DefaultDuration ), 0x3728, 10, 10, m_EffectID, 0 );
+
+				if ( m_SoundID != -1 )
+					Effects.PlaySound( m_Location, m_Map, m_SoundID );
+			}
+		}
+
+		private class DelayTimer : Timer
+		{
+			private HouseTeleporter m_Teleporter;
+			private Mobile m_Mobile;
+
+			public DelayTimer( HouseTeleporter tp, Mobile m ) : base( TimeSpan.FromSeconds( 1.0 ) )
+			{
+				m_Teleporter = tp;
+				m_Mobile = m;
+			}
+
+			protected override void OnTick()
+			{
+				Item target = m_Teleporter.m_Target;
+
+				if ( target != null && !target.Deleted )
+				{
+					Mobile m = m_Mobile;
+
+					if ( m.Location == m_Teleporter.Location && m.Map == m_Teleporter.Map )
+					{
+						Point3D p = target.GetWorldTop();
+						Map map = target.Map;
+
+						Server.Mobiles.BaseCreature.TeleportPets( m, p, map );
+
+						m.MoveToWorld( p, map );
+
+						if ( !m.Hidden || m.AccessLevel == AccessLevel.Player )
+						{
+							Effects.PlaySound( target.Location, target.Map, 0x1FE );
+
+							Effects.SendLocationParticles( EffectItem.Create( m_Teleporter.Location, m_Teleporter.Map, EffectItem.DefaultDuration ), 0x3728, 10, 10, 2023, 0 );
+							Effects.SendLocationParticles( EffectItem.Create( target.Location, target.Map, EffectItem.DefaultDuration ), 0x3728, 10, 10, 5023, 0 );
+
+							new EffectTimer( target.Location, target.Map, 2023, -1, TimeSpan.FromSeconds( 0.4 ) ).Start();
+						}
+					}
+				}
+			}
+		}
+	}
+}

Scripts/Multis/Houses.cs

@@ -0,0 +1,577 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Items;
+using Server.Multis.Deeds;
+
+namespace Server.Multis
+{
+	public class SmallOldHouse : BaseHouse
+	{
+		public static Rectangle2D[] AreaArray = new Rectangle2D[]{ new Rectangle2D(-3,-3,7,7 ), new Rectangle2D( -1, 4, 3, 1 ) };
+
+		public override Rectangle2D[] Area{ get{ return AreaArray; } }
+		public override Point3D BaseBanLocation{ get{ return new Point3D( 2, 4, 0 ); } }
+
+		public override int DefaultPrice{ get{ return 43800; } }
+
+		public override HousePlacementEntry ConvertEntry{ get{ return HousePlacementEntry.TwoStoryFoundations[0]; } }
+
+		public SmallOldHouse( Mobile owner, int id ) : base( id, owner, 425, 3 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			AddSouthDoor( 0, 3, 7, keyValue );
+
+			SetSign( 2, 4, 5 );
+		}
+
+		public SmallOldHouse( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() 
+		{
+			switch ( ItemID )
+			{
+				case 0x64: return new StonePlasterHouseDeed();
+				case 0x66: return new FieldStoneHouseDeed();
+				case 0x68: return new SmallBrickHouseDeed();
+				case 0x6A: return new WoodHouseDeed();
+				case 0x6C: return new WoodPlasterHouseDeed(); 
+				case 0x6E: 
+				default: return new ThatchedRoofCottageDeed();
+			}
+		}
+
+		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();
+		}
+	}
+
+	public class GuildHouse : BaseHouse
+	{
+		public static Rectangle2D[] AreaArray = new Rectangle2D[]{ new Rectangle2D( -7, -7, 14, 14 ), new Rectangle2D( -2, 7, 4, 1 ) };
+
+		public override int DefaultPrice{ get{ return 144500; } }
+
+		public override HousePlacementEntry ConvertEntry{ get{ return HousePlacementEntry.ThreeStoryFoundations[20]; } }
+		public override int ConvertOffsetX{ get{ return -1; } }
+		public override int ConvertOffsetY{ get{ return -1; } }
+
+		public override Rectangle2D[] Area{ get{ return AreaArray; } }
+		public override Point3D BaseBanLocation{ get{ return new Point3D( 4, 8, 0 ); } }
+
+		public GuildHouse( Mobile owner ) : base( 0x74, owner, 1100, 8 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			AddSouthDoors( -1, 6, 7, keyValue );
+
+			SetSign( 4, 8, 16 );
+
+			AddSouthDoor( -3, -1, 7 );
+			AddSouthDoor(  3, -1, 7 );
+		}
+
+		public GuildHouse( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() { return new BrickHouseDeed(); }
+
+		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();
+		}
+	}
+
+	public class TwoStoryHouse : BaseHouse
+	{
+		public static Rectangle2D[] AreaArray = new Rectangle2D[]{ new Rectangle2D( -7, 0, 14, 7 ), new Rectangle2D( -7, -7, 9, 7 ), new Rectangle2D( -4, 7, 4, 1 ) };
+
+		public override Rectangle2D[] Area{ get{ return AreaArray; } }
+		public override Point3D BaseBanLocation{ get{ return new Point3D( 2, 8, 0 ); } }
+
+		public override int DefaultPrice{ get{ return 192400; } }
+
+		public TwoStoryHouse( Mobile owner, int id ) : base( id, owner, 1370, 10 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			AddSouthDoors( -3, 6, 7, keyValue );
+
+			SetSign( 2, 8, 16 );
+
+			AddSouthDoor( -3, 0, 7 );
+			AddSouthDoor( id == 0x76 ? -2 : -3, 0, 27 );
+		}
+
+		public TwoStoryHouse( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() 
+		{ 
+			switch( ItemID )
+			{
+				case 0x76: return new TwoStoryWoodPlasterHouseDeed();
+				case 0x78:
+				default: return new TwoStoryStonePlasterHouseDeed();
+			}
+		}
+
+		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();
+		}
+	}
+
+	public class Tower : BaseHouse
+	{
+		public static Rectangle2D[] AreaArray = new Rectangle2D[]{ new Rectangle2D( -7, -7, 16, 14 ), new Rectangle2D( -1, 7, 4, 2 ), new Rectangle2D( -11, 0, 4, 7 ), new Rectangle2D( 9, 0, 4, 7 ) };
+
+		public override int DefaultPrice{ get{ return 433200; } }
+
+		public override HousePlacementEntry ConvertEntry{ get{ return HousePlacementEntry.ThreeStoryFoundations[37]; } }
+		public override int ConvertOffsetY{ get{ return -1; } }
+
+		public override Rectangle2D[] Area{ get{ return AreaArray; } }
+		public override Point3D BaseBanLocation{ get{ return new Point3D( 5, 8, 0 ); } }
+
+		public Tower( Mobile owner ) : base( 0x7A, owner, 2119, 15 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			AddSouthDoors( false, 0, 6, 6, keyValue );
+
+			SetSign( 5, 8, 16 );
+
+			AddSouthDoor( false, 3, -2, 6 );
+			AddEastDoor( false, 1, 4, 26 );
+			AddEastDoor( false, 1, 4, 46 );
+		}
+
+		public Tower( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() { return new TowerDeed(); }
+
+		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();
+		}
+	}
+
+	public class Keep : BaseHouse//warning: ODD shape!
+	{
+		public static Rectangle2D[] AreaArray = new Rectangle2D[]{ new Rectangle2D( -11, -11, 7, 8 ), new Rectangle2D( -11, 5, 7, 8 ), new Rectangle2D( 6, -11, 7, 8 ), new Rectangle2D( 6, 5, 7, 8 ), new Rectangle2D( -9, -3, 5, 8 ), new Rectangle2D( 6, -3, 5, 8 ), new Rectangle2D( -4, -9, 10, 20 ), new Rectangle2D( -1, 11, 4, 1 ) };
+
+		public override int DefaultPrice{ get{ return 665200; } }
+
+		public override Rectangle2D[] Area{ get{ return AreaArray; } }
+		public override Point3D BaseBanLocation{ get{ return new Point3D( 5, 13, 0 ); } }
+
+		public Keep( Mobile owner ) : base( 0x7C, owner, 2625, 18 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			AddSouthDoors( false, 0, 10, 6, keyValue );
+			
+			SetSign( 5, 12, 16 );
+		}
+
+		public Keep( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() { return new KeepDeed(); }
+
+		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();
+		}
+	}
+
+	public class Castle : BaseHouse
+	{
+		public static Rectangle2D[] AreaArray = new Rectangle2D[]{  new Rectangle2D( -15, -15, 31, 31 ), new Rectangle2D( -1, 16, 4, 1 ) };
+
+		public override int DefaultPrice{ get{ return 1022800; } }
+
+		public override Rectangle2D[] Area{ get{ return AreaArray; } }
+		public override Point3D BaseBanLocation{ get{ return new Point3D( 5, 17, 0 ); } }
+
+		public Castle( Mobile owner ) : base( 0x7E, owner, 4076, 28 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			AddSouthDoors( false, 0, 15, 6, keyValue );
+
+			SetSign( 5, 17, 16 );
+
+			AddSouthDoors( false, 0, 11, 6, true );
+			AddSouthDoors( false, 0, 5, 6, false );
+			AddSouthDoors( false, -1, -11, 6, false );
+		}
+
+		public Castle( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() { return new CastleDeed(); }
+
+		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();
+		}
+	}
+
+	public class LargePatioHouse : BaseHouse
+	{
+		public static Rectangle2D[] AreaArray = new Rectangle2D[]{ new Rectangle2D( -7, -7, 15, 14 ), new Rectangle2D( -5, 7, 4, 1 ) };
+
+		public override int DefaultPrice{ get{ return 152800; } }
+
+		public override HousePlacementEntry ConvertEntry{ get{ return HousePlacementEntry.ThreeStoryFoundations[29]; } }
+		public override int ConvertOffsetY{ get{ return -1; } }
+
+		public override Rectangle2D[] Area { get { return AreaArray; } }
+		public override Point3D BaseBanLocation { get { return new Point3D( 1, 8, 0 ); } }
+
+		public LargePatioHouse( Mobile owner ) : base( 0x8C, owner, 1100, 8 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			AddSouthDoors( -4, 6, 7, keyValue );
+			
+			SetSign( 1, 8, 16 );
+
+			AddEastDoor( 1, 4, 7 );
+			AddEastDoor( 1, -4, 7 );
+			AddSouthDoor( 4, -1, 7 );
+		}
+
+		public LargePatioHouse( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() { return new LargePatioDeed(); }
+
+		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();
+		}
+	}
+
+	public class LargeMarbleHouse : BaseHouse
+	{
+		public static Rectangle2D[] AreaArray = new Rectangle2D[]{ new Rectangle2D( -7, -7, 15, 14 ), new Rectangle2D( -6, 7, 6, 1 ) };
+
+		public override int DefaultPrice{ get{ return 192000; } }
+
+		public override HousePlacementEntry ConvertEntry{ get{ return HousePlacementEntry.ThreeStoryFoundations[29]; } }
+		public override int ConvertOffsetY{ get{ return -1; } }
+
+		public override Rectangle2D[] Area { get { return AreaArray; } }
+		public override Point3D BaseBanLocation { get { return new Point3D( 1, 8, 0 ); } }
+
+		public LargeMarbleHouse( Mobile owner ) : base( 0x96, owner, 1370, 10 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			AddSouthDoors( false, -4, 3, 4, keyValue );
+
+			SetSign( 1, 8, 11 );
+		}
+
+		public LargeMarbleHouse( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() { return new LargeMarbleDeed(); }
+
+		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();
+		}
+	}
+
+	public class SmallTower : BaseHouse
+	{
+		public static Rectangle2D[] AreaArray = new Rectangle2D[]{ new Rectangle2D( -3, -3, 8, 7 ), new Rectangle2D( 2, 4, 3, 1 ) };
+
+		public override int DefaultPrice{ get{ return 88500; } }
+
+		public override HousePlacementEntry ConvertEntry{ get{ return HousePlacementEntry.TwoStoryFoundations[6]; } }
+
+		public override Rectangle2D[] Area{ get{ return AreaArray; } }
+		public override Point3D BaseBanLocation{ get{ return new Point3D( 1, 4, 0 ); } }
+
+		public SmallTower( Mobile owner ) : base( 0x98, owner, 580, 4 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			AddSouthDoor( false, 3, 3, 6, keyValue );
+
+			SetSign( 1, 4, 5 );
+		}
+
+		public SmallTower( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() { return new SmallTowerDeed(); }
+
+		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();
+		}
+	}
+
+	public class LogCabin : BaseHouse
+	{
+		public static Rectangle2D[] AreaArray = new Rectangle2D[]{ new Rectangle2D( -3, -6, 8, 13 ) };
+
+		public override int DefaultPrice{ get{ return 97800; } }
+
+		public override HousePlacementEntry ConvertEntry{ get{ return HousePlacementEntry.TwoStoryFoundations[12]; } }
+
+		public override Rectangle2D[] Area { get { return AreaArray; } }
+		public override Point3D BaseBanLocation { get { return new Point3D( 5, 8, 0 ); } }
+
+		public LogCabin( Mobile owner ) : base( 0x9A, owner, 1100, 8 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			AddSouthDoor( 1, 4, 8, keyValue );
+			
+			SetSign( 5, 8, 20 );
+
+			AddSouthDoor( 1, 0, 29 );
+		}
+
+		public LogCabin( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() { return new LogCabinDeed(); }
+
+		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();
+		}
+	}
+
+	public class SandStonePatio : BaseHouse
+	{
+		public static Rectangle2D[] AreaArray = new Rectangle2D[]{ new Rectangle2D( -5, -4, 12, 8 ), new Rectangle2D( -2, 4, 3, 1 ) };
+
+		public override int DefaultPrice{ get{ return 90900; } }
+
+		public override HousePlacementEntry ConvertEntry{ get{ return HousePlacementEntry.TwoStoryFoundations[35]; } }
+		public override int ConvertOffsetY{ get{ return -1; } }
+
+		public override Rectangle2D[] Area { get { return AreaArray; } }
+		public override Point3D BaseBanLocation { get { return new Point3D( 4, 6, 0 ); } }
+
+		public SandStonePatio( Mobile owner ) : base( 0x9C, owner, 850, 6 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			AddSouthDoor( -1, 3, 6, keyValue );
+			
+			SetSign( 4, 6, 24 );
+		}
+
+		public SandStonePatio( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() { return new SandstonePatioDeed(); }
+
+		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();
+		}
+	}
+
+	public class TwoStoryVilla : BaseHouse
+	{
+		public static Rectangle2D[] AreaArray = new Rectangle2D[]{ new Rectangle2D( -5, -5, 11, 11 ), new Rectangle2D( 2, 6, 4, 1 ) };
+
+		public override int DefaultPrice{ get{ return 136500; } }
+
+		public override HousePlacementEntry ConvertEntry{ get{ return HousePlacementEntry.TwoStoryFoundations[31]; } }
+
+		public override Rectangle2D[] Area{ get{ return AreaArray; } }
+		public override Point3D BaseBanLocation{ get{ return new Point3D( 3, 8, 0 ); } }
+
+		public TwoStoryVilla( Mobile owner ) : base( 0x9E, owner, 1100, 8 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			AddSouthDoors( 3, 1, 5, keyValue );
+			
+			SetSign( 3, 8, 24 );
+
+			AddEastDoor( 1, 0, 25 );
+			AddSouthDoor( -3, -1, 25 );
+		}
+
+		public TwoStoryVilla( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() { return new VillaDeed(); }
+
+		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();
+		}
+	}
+
+	public class SmallShop : BaseHouse
+	{
+		public override Rectangle2D[] Area { get { return ( ItemID == 0x40A2 ? AreaArray1 : AreaArray2 ); } }
+		public override Point3D BaseBanLocation { get { return new Point3D( 3, 4, 0 ); } }
+
+		public override int DefaultPrice{ get{ return 63000; } }
+
+		public override HousePlacementEntry ConvertEntry{ get{ return HousePlacementEntry.TwoStoryFoundations[0]; } }
+
+		public static Rectangle2D[] AreaArray1 = new Rectangle2D[]{ new Rectangle2D(-3,-3,7,7), new Rectangle2D( -1, 4, 4, 1 ) };
+		public static Rectangle2D[] AreaArray2 = new Rectangle2D[]{ new Rectangle2D(-3,-3,7,7), new Rectangle2D( -2, 4, 3, 1 ) };
+
+		public SmallShop( Mobile owner, int id ) : base( id, owner, 425, 3 )
+		{
+			uint keyValue = CreateKeys( owner );
+
+			BaseDoor door = MakeDoor( false, DoorFacing.EastCW );
+
+			door.Locked = true;
+			door.KeyValue = keyValue;
+
+			if ( door is BaseHouseDoor )
+				((BaseHouseDoor)door).Facing = DoorFacing.EastCCW;
+
+			AddDoor( door, -2, 0, id == 0xA2 ? 24 : 27 );
+
+			//AddSouthDoor( false, -2, 0, 27 - (id == 0xA2 ? 3 : 0), keyValue );
+			
+			SetSign( 3, 4, 7 - (id == 0xA2 ? 2 : 0) );
+		}
+
+		public SmallShop( Serial serial ) : base( serial )
+		{
+		}
+
+		public override HouseDeed GetDeed() 
+		{ 
+			switch ( ItemID )
+			{
+				case 0xA0: return new StoneWorkshopDeed(); 
+				case 0xA2:
+				default: return new MarbleWorkshopDeed();
+			}
+		}
+
+		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/Multis/MovingCrate.cs

@@ -0,0 +1,339 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Multis
+{
+	public class MovingCrate : Container
+	{
+		public static readonly int MaxItemsPerSubcontainer = 20;
+		public static readonly int Rows = 3;
+		public static readonly int Columns = 5;
+		public static readonly int HorizontalSpacing = 25;
+		public static readonly int VerticalSpacing = 25;
+
+		public override int LabelNumber{ get{ return 1061690; } } // Packing Crate
+
+		private BaseHouse m_House;
+
+		private Timer m_InternalizeTimer;
+
+		public BaseHouse House
+		{
+			get{ return m_House; }
+			set{ m_House = value; }
+		}
+
+		public override int DefaultMaxItems{ get{ return 0; } }
+		public override int DefaultMaxWeight{ get{ return 0; } }
+
+		public MovingCrate( BaseHouse house ) : base( 0xE3D )
+		{
+			Hue = 0x8A5;
+			Movable = false;
+
+			m_House = house;
+		}
+
+		public MovingCrate( Serial serial ) : base( serial )
+		{
+		}
+
+		/*
+		public override void AddNameProperties( ObjectPropertyList list )
+		{
+			base.AddNameProperties( list );
+
+			if ( House != null && House.InternalizedVendors.Count > 0 )
+				list.Add( 1061833, House.InternalizedVendors.Count.ToString() ); // This packing crate contains ~1_COUNT~ vendors/barkeepers.
+		}
+		*/
+
+		public override void DropItem( Item dropped )
+		{
+			// 1. Try to stack the item
+			foreach ( Item item in this.Items )
+			{
+				if ( item is PackingBox )
+				{
+					List<Item> subItems = item.Items;
+
+					for ( int i = 0; i < subItems.Count; i++ )
+					{
+						Item subItem = subItems[i];
+
+						if ( !(subItem is Container) && subItem.StackWith( null, dropped, false ) )
+							return;
+					}
+				}
+			}
+
+			// 2. Try to drop the item into an existing container
+			foreach ( Item item in this.Items )
+			{
+				if ( item is PackingBox )
+				{
+					Container box = (Container) item;
+					List<Item> subItems = box.Items;
+
+					if ( subItems.Count < MaxItemsPerSubcontainer )
+					{
+						box.DropItem( dropped );
+						return;
+					}
+				}
+			}
+
+			// 3. Drop the item into a new container
+			Container subContainer = new PackingBox();
+			subContainer.DropItem( dropped );
+
+			Point3D location = GetFreeLocation();
+			if ( location != Point3D.Zero )
+			{
+				this.AddItem( subContainer );
+				subContainer.Location = location;
+			}
+			else
+			{
+				base.DropItem( subContainer );
+			}
+		}
+
+		private Point3D GetFreeLocation()
+		{
+			bool[,] positions = new bool[Rows, Columns];
+
+			foreach ( Item item in this.Items )
+			{
+				if ( item is PackingBox )
+				{
+					int i = (item.Y - this.Bounds.Y) / VerticalSpacing;
+					if ( i < 0 )
+						i = 0;
+					else if ( i >= Rows )
+						i = Rows - 1;
+
+					int j = (item.X - this.Bounds.X) / HorizontalSpacing;
+					if ( j < 0 )
+						j = 0;
+					else if ( j >= Columns )
+						j = Columns - 1;
+
+					positions[i, j] = true;
+				}
+			}
+
+			for ( int i = 0; i < Rows; i++ )
+			{
+				for ( int j = 0; j < Columns; j++ )
+				{
+					if ( !positions[i, j] )
+					{
+						int x = this.Bounds.X + j * HorizontalSpacing;
+						int y = this.Bounds.Y + i * VerticalSpacing;
+
+						return new Point3D( x, y, 0 );
+					}
+				}
+			}
+
+			return Point3D.Zero;
+		}
+
+		public override bool IsDecoContainer
+		{
+			get{ return false; }
+		}
+
+		public override bool CheckHold( Mobile m, Item item, bool message, bool checkItems, int plusItems, int plusWeight )
+		{
+			if ( m.AccessLevel < AccessLevel.GameMaster )
+			{
+				m.SendLocalizedMessage( 1061145 ); // You cannot place items into a house moving crate.
+				return false;
+			}
+
+			return base.CheckHold( m, item, message, checkItems, plusItems, plusWeight );
+		}
+
+		public override bool CheckLift( Mobile from, Item item, ref LRReason reject )
+		{
+			return base.CheckLift( from, item, ref reject ) && House != null && !House.Deleted && House.IsOwner( from );
+		}
+
+		public override bool CheckItemUse( Mobile from, Item item )
+		{
+			return base.CheckItemUse( from, item ) && House != null && !House.Deleted && House.IsOwner( from );
+		}
+
+		public override void OnItemRemoved( Item item )
+		{
+			base.OnItemRemoved( item );
+
+			if ( this.TotalItems == 0 )
+				Delete();
+		}
+
+		public void RestartTimer()
+		{
+			if ( m_InternalizeTimer == null )
+			{
+				m_InternalizeTimer = new InternalizeTimer( this );
+				m_InternalizeTimer.Start();
+			}
+			else
+			{
+				m_InternalizeTimer.Stop();
+				m_InternalizeTimer.Start();
+			}
+		}
+
+		public void Hide()
+		{
+			if ( m_InternalizeTimer != null )
+			{
+				m_InternalizeTimer.Stop();
+				m_InternalizeTimer = null;
+			}
+
+			List<Item> toRemove = new List<Item>();
+			foreach ( Item item in this.Items )
+				if ( item is PackingBox && item.Items.Count == 0 )
+					toRemove.Add( item );
+
+			foreach ( Item item in toRemove )
+				item.Delete();
+
+			if ( this.TotalItems == 0 )
+				Delete();
+			else
+				Internalize();
+		}
+
+		public override void OnAfterDelete()
+		{
+			base.OnAfterDelete();
+
+			if ( House != null && House.MovingCrate == this )
+				House.MovingCrate = null;
+
+			if ( m_InternalizeTimer != null )
+				m_InternalizeTimer.Stop();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.WriteEncodedInt( 1 );
+
+			writer.Write( (Item) m_House );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadEncodedInt();
+
+			m_House = reader.ReadItem() as BaseHouse;
+			
+			if( m_House != null )
+			{
+				m_House.MovingCrate = this;
+				Timer.DelayCall( TimeSpan.Zero, new TimerCallback( Hide ) );
+			}
+			else
+			{
+				Timer.DelayCall( TimeSpan.Zero, this.Delete );
+			}
+
+			if ( version == 0 )
+				MaxItems = -1; // reset to default
+		}
+
+		public class InternalizeTimer : Timer
+		{
+			private MovingCrate m_Crate;
+
+			public InternalizeTimer( MovingCrate crate ) : base( TimeSpan.FromMinutes( 5.0 ) )
+			{
+				m_Crate = crate;
+
+				Priority = TimerPriority.FiveSeconds;
+			}
+
+			protected override void OnTick()
+			{
+				m_Crate.Hide();
+			}
+		}
+	}
+
+	public class PackingBox : BaseContainer
+	{
+		public override int LabelNumber{ get{ return 1061690; } } // Packing Crate
+
+		public override int DefaultGumpID{ get{ return 0x4B; } }
+		public override int DefaultDropSound{ get{ return 0x42; } }
+
+		public override Rectangle2D Bounds
+		{
+			get{ return new Rectangle2D( 16, 51, 168, 73 ); }
+		}
+
+		public override int DefaultMaxItems{ get{ return 0; } }
+		public override int DefaultMaxWeight{ get{ return 0; } }
+
+		public PackingBox() : base( 0x9A8 )
+		{
+			Movable = false;
+		}
+
+		public PackingBox( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void SendCantStoreMessage( Mobile to, Item item )
+		{
+			to.SendLocalizedMessage( 1061145 ); // You cannot place items into a house moving crate.
+		}
+
+		public override void OnItemRemoved( Item item )
+		{
+			base.OnItemRemoved( item );
+
+			if ( item.GetBounce() == null && this.TotalItems == 0 )
+				Delete();
+		}
+
+		public override void OnItemBounceCleared( Item item )
+		{
+			base.OnItemBounceCleared( item );
+
+			if ( this.TotalItems == 0 )
+				Delete();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.WriteEncodedInt( 1 ); // version
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadEncodedInt();
+
+			if ( version == 0 )
+				MaxItems = -1; // reset to default
+		}
+	}
+}

Scripts/Multis/PreviewHouse.cs

@@ -0,0 +1,145 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server;
+using Server.Items;
+
+namespace Server.Multis
+{
+	public class PreviewHouse : BaseMulti
+	{
+		private List<Item> m_Components;
+		private Timer m_Timer;
+
+		public PreviewHouse( int multiID ) : base( multiID )
+		{
+			m_Components = new List<Item>();
+
+			MultiComponentList mcl = this.Components;
+
+			for ( int i = 1; i < mcl.List.Length; ++i )
+			{
+				MultiTileEntry entry = mcl.List[i];
+
+				if ( entry.m_Flags == 0 )
+				{
+					Item item = new Static( (int)entry.m_ItemID );
+
+					item.MoveToWorld( new Point3D( X + entry.m_OffsetX, Y + entry.m_OffsetY, Z + entry.m_OffsetZ ), Map );
+
+					m_Components.Add( item );
+				}
+			}
+
+			m_Timer = new DecayTimer( this );
+			m_Timer.Start();
+		}
+
+		public override void OnLocationChange( Point3D oldLocation )
+		{
+			base.OnLocationChange( oldLocation );
+
+			if ( m_Components == null )
+				return;
+
+			int xOffset = X - oldLocation.X;
+			int yOffset = Y - oldLocation.Y;
+			int zOffset = Z - oldLocation.Z;
+
+			for ( int i = 0; i < m_Components.Count; ++i )
+			{
+				Item item = m_Components[i];
+
+				item.MoveToWorld( new Point3D( item.X + xOffset, item.Y + yOffset, item.Z + zOffset ), this.Map );
+			}
+		}
+
+		public override void OnMapChange()
+		{
+			base.OnMapChange();
+
+			if ( m_Components == null )
+				return;
+
+			for ( int i = 0; i < m_Components.Count; ++i )
+			{
+				Item item = m_Components[i];
+
+				item.Map = this.Map;
+			}
+		}
+
+		public override void OnDelete()
+		{
+			base.OnDelete();
+
+			if ( m_Components == null )
+				return;
+
+			for ( int i = 0; i < m_Components.Count; ++i )
+			{
+				Item item = m_Components[i];
+
+				item.Delete();
+			}
+		}
+
+		public override void OnAfterDelete()
+		{
+			if ( m_Timer != null )
+				m_Timer.Stop();
+
+			m_Timer = null;
+
+			base.OnAfterDelete();
+		}
+
+		public PreviewHouse( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+
+			writer.Write( m_Components );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			switch ( version )
+			{
+				case 0:
+				{
+					m_Components = reader.ReadStrongItemList();
+
+					break;
+				}
+			}
+
+			Timer.DelayCall( TimeSpan.Zero, new TimerCallback( this.Delete ) );
+		}
+
+		private class DecayTimer : Timer
+		{
+			private Item m_Item;
+
+			public DecayTimer( Item item ) : base( TimeSpan.FromSeconds( 20.0 ) )
+			{
+				m_Item = item;
+				Priority = TimerPriority.OneSecond;
+			}
+
+			protected override void OnTick()
+			{
+				m_Item.Delete();
+			}
+		}
+	}
+}