Overwrite

Complete Overwrite of the Folder with the free shard. ServUO 57.3 has been added.

Scripts/Services/CleanUpBritannia/Items/ArachnidDoom.cs

@@ -0,0 +1,57 @@
+using System;
+
+namespace Server.Items
+{
+    public class ArachnidDoom : BaseInstrument
+    {
+        [Constructable]
+        public ArachnidDoom()
+        {
+            this.Hue = 1944;
+            this.Weight = 4;
+            this.Slayer = SlayerName.ArachnidDoom;
+
+            UsesRemaining = 450;
+        }       
+
+        public ArachnidDoom(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1154724;
+            }
+        }// Arachnid Doom
+        public override int InitMinUses
+        {
+            get
+            {
+                return 450;
+            }
+        }
+        public override int InitMaxUses
+        {
+            get
+            {
+                return 450;
+            }
+        }
+        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/Services/CleanUpBritannia/Items/Bamboo.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace Server.Items
+{
+    public class Bamboo : Item
+    {
+        [Constructable]
+        public Bamboo()
+            : base(0x246D)
+        {
+            this.Weight = 10;
+        }
+
+        public Bamboo(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1029324;
+            }
+        }// bamboo
+        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/Services/CleanUpBritannia/Items/Beehive.cs

@@ -0,0 +1,199 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server;
+using Server.ContextMenus;
+using Server.Network;
+using Server.Gumps;
+using Server.Multis;
+
+namespace Server.Items
+{
+	public class Beehive : Item, ISecurable
+	{
+		private static readonly TimeSpan m_SpawnTime = TimeSpan.FromHours( 4.0 );
+
+		private int m_Honeypots;
+		private DateTime m_NextSpawnTime;
+		private SpawnTimer m_SpawnTimer;
+		private Item m_Bees;
+
+		private SecureLevel m_Level;
+
+		public override bool ForceShowProperties { get { return true; } }
+
+		public override int LabelNumber { get { return 1080263; } } // Beehive
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public SecureLevel Level { get { return m_Level; } set { m_Level = value; } }
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int Honeypots
+		{
+			get { return m_Honeypots; }
+			set
+			{
+				if ( value >= 10 )
+				{
+					m_Honeypots = 10;
+
+					StopSpawnTimer();
+				}
+				else
+				{
+					if ( value <= 0 )
+						m_Honeypots = 0;
+					else
+						m_Honeypots = value;
+
+					StartSpawnTimer( m_SpawnTime );
+				}
+
+				InvalidateProperties();
+			}
+		}
+
+		[Constructable]
+		public Beehive()
+			: base( 2330 )
+		{
+			Weight = 10.0;
+
+			m_Honeypots = 0;
+			StartSpawnTimer( TimeSpan.FromMinutes( 1.0 ) );
+		}
+
+		public override void GetProperties( ObjectPropertyList list )
+		{
+			base.GetProperties( list );
+
+			list.Add( 1080202, Honeypots.ToString() ); // Honeypots: ~1_COUNT~
+		}
+
+		public override void GetContextMenuEntries( Mobile from, List<ContextMenuEntry> list )
+		{
+			base.GetContextMenuEntries( from, list );
+
+			SetSecureLevelEntry.AddTo( from, this, list );
+		}
+
+		private void StartSpawnTimer( TimeSpan delay )
+		{
+			StopSpawnTimer();
+
+			m_SpawnTimer = new SpawnTimer( this, delay );
+			m_SpawnTimer.Start();
+
+			m_NextSpawnTime = DateTime.UtcNow + delay;
+		}
+
+		private void StopSpawnTimer()
+		{
+			if ( m_SpawnTimer != null )
+			{
+				m_SpawnTimer.Stop();
+				m_SpawnTimer = null;
+			}
+		}
+
+		private class SpawnTimer : Timer
+		{
+			private Beehive m_Beehive;
+
+			public SpawnTimer( Beehive beehive, TimeSpan delay )
+				: base( delay )
+			{
+				m_Beehive = beehive;
+
+			}
+
+			protected override void OnTick()
+			{
+				if ( m_Beehive.Deleted )
+				{
+					return;
+				}
+
+				m_Beehive.m_SpawnTimer = null;
+				m_Beehive.Honeypots++;
+			}
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( !from.InRange( GetWorldLocation(), 2 ) )
+			{
+				from.LocalOverheadMessage( MessageType.Regular, 0x3B2, 1019045 ); // I can't reach that.
+			}
+			else if ( Honeypots > 0 )
+			{
+				from.AddToBackpack( new JarHoney() );
+				Honeypots--;
+			}
+		}
+
+		public override void OnLockDownChange()
+		{
+			if ( IsLockedDown )
+			{
+				if ( m_Bees == null )
+				{
+					m_Bees = new Item( 2331 );
+					m_Bees.MoveToWorld( Location, Map );
+					m_Bees.Movable = false;
+				}
+			}
+			else
+			{
+				if ( m_Bees != null )
+				{
+					m_Bees.Delete();
+					m_Bees = null;
+				}
+			}
+		}
+
+		public Beehive( Serial serial )
+			: base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.WriteEncodedInt( (int) 1 ); // version
+
+			writer.Write( (Item) m_Bees );
+			writer.WriteEncodedInt( (int) m_Honeypots );
+			writer.WriteDeltaTime( (DateTime) m_NextSpawnTime );
+			writer.WriteEncodedInt( (int) m_Level );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadEncodedInt();
+
+			switch ( version )
+			{
+				case 1:
+					{
+						m_Bees = reader.ReadItem();
+						goto case 0;
+					}
+				case 0:
+					{
+						m_Honeypots = reader.ReadEncodedInt();
+						m_NextSpawnTime = reader.ReadDeltaTime();
+						m_Level = (SecureLevel) reader.ReadEncodedInt();
+						break;
+					}
+			}
+
+			if ( m_Honeypots < 10 )
+				StartSpawnTimer( m_NextSpawnTime - DateTime.UtcNow );
+		}
+	}
+}

Scripts/Services/CleanUpBritannia/Items/BootsOfTheCrystalHydra.cs

@@ -0,0 +1,37 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class BootsOfTheCrystalHydra : Boots
+	{
+		public override int LabelNumber { get { return 1151209; } } // Boots of the Crystal Hydra
+		public override bool IsArtifact { get { return true; } }
+
+		[Constructable]
+		public BootsOfTheCrystalHydra()
+		{
+			Hue = 0x47E;
+			Resistances.Energy = 2;
+		}
+
+		public BootsOfTheCrystalHydra( Serial serial )
+			: base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/CleanUpBritannia/Items/BootsOfTheIceWyrm.cs

@@ -0,0 +1,37 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class BootsOfTheIceWyrm : Boots
+	{
+		public override int LabelNumber { get { return 1151208; } } // Boots of the Ice Wyrm
+		public override bool IsArtifact { get { return true; } }
+
+		[Constructable]
+		public BootsOfTheIceWyrm()
+		{
+			Hue = 0x482;
+			Resistances.Cold = 2;
+		}
+
+		public BootsOfTheIceWyrm( Serial serial )
+			: base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/CleanUpBritannia/Items/BootsOfTheLavaLizard.cs

@@ -0,0 +1,37 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class BootsOfTheLavaLizard : Boots
+	{
+		public override int LabelNumber { get { return 1151207; } } // Boots Of The Lava Lizard
+		public override bool IsArtifact { get { return true; } }
+
+		[Constructable]
+		public BootsOfTheLavaLizard()
+		{
+			Hue = 0x674;
+			Resistances.Fire = 2;
+		}
+
+		public BootsOfTheLavaLizard( Serial serial )
+			: base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/CleanUpBritannia/Items/BootsOfTheThrasher.cs

@@ -0,0 +1,37 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class BootsOfTheThrasher : Boots
+	{
+		public override int LabelNumber { get { return 1151210; } } // Snake Skin Boots
+		public override bool IsArtifact { get { return true; } }
+
+		[Constructable]
+		public BootsOfTheThrasher()
+		{
+			Hue = 0x497;
+			Resistances.Physical = 2;
+		}
+
+		public BootsOfTheThrasher( Serial serial )
+			: base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/CleanUpBritannia/Items/ChaosTile.cs

@@ -0,0 +1,69 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class ChaosTileAddon : BaseAddon
+	{
+		public override BaseAddonDeed Deed { get { return new ChaosTileDeed(); } }
+
+		[Constructable]
+		public ChaosTileAddon()
+		{
+			AddComponent( new AddonComponent( 5347 ), 0, 0, 0 );
+			AddComponent( new AddonComponent( 5348 ), 0, 1, 0 );
+			AddComponent( new AddonComponent( 5349 ), 1, 1, 0 );
+			AddComponent( new AddonComponent( 5350 ), 1, 0, 0 );
+		}
+
+		public ChaosTileAddon( 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();
+        }
+	}
+
+	public class ChaosTileDeed : BaseAddonDeed
+	{
+		public override BaseAddon Addon { get { return new ChaosTileAddon(); } }
+		public override int LabelNumber { get { return 1080490; } } // Chaos Tile Deed
+
+		[Constructable]
+		public ChaosTileDeed()
+		{
+			LootType = LootType.Blessed;
+		}
+
+		public ChaosTileDeed( 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/Services/CleanUpBritannia/Items/ChestOfDrawers.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Server.Items
+{
+    [Furniture]
+    [Flipable(0x0A2C, 0x0A34)]
+    public class ChestOfDrawers : LockableContainer
+    {
+        [Constructable]
+        public ChestOfDrawers()
+            : base(0x0A2C)
+        {
+            this.Weight = 25.0;
+        }
+
+        public ChestOfDrawers(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int DefaultGumpID
+        {
+            get
+            {
+                return 0x51;
+            }
+        }
+        public override int DefaultDropSound
+        {
+            get
+            {
+                return 0x42;
+            }
+        }
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1022604;
+            }
+        }// chest of drawers
+
+        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/Services/CleanUpBritannia/Items/CompassionVirtueTile.cs

@@ -0,0 +1,117 @@
+using System;
+using Server;
+using Server.Gumps;
+
+namespace Server.Items
+{
+	public enum CompassionTileType
+	{
+		North = 0,
+		West = 1,
+	}
+
+	public class CompassionVirtueTileAddon : BaseAddon
+	{
+		public override BaseAddonDeed Deed { get { return new CompassionVirtueTileDeed(); } }
+
+		private CompassionTileType m_CompassionTileType;
+
+		private int offset;
+
+		[Constructable]
+		public CompassionVirtueTileAddon( CompassionTileType type )
+		{
+			m_CompassionTileType = type;
+
+			offset = 0;
+
+			if ( type == CompassionTileType.North )
+			{
+				offset = 4;
+			}
+
+			AddComponent( new AddonComponent( 5287 + offset ), 0, 0, 0 );
+			AddComponent( new AddonComponent( 5288 + offset ), 0, 1, 0 );
+			AddComponent( new AddonComponent( 5289 + offset ), 1, 1, 0 );
+			AddComponent( new AddonComponent( 5290 + offset ), 1, 0, 0 );
+		}
+
+		public CompassionVirtueTileAddon( 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();
+        }
+	}
+
+	public class CompassionVirtueTileDeed : BaseAddonDeed, IRewardOption
+	{
+		public override BaseAddon Addon { get { return new CompassionVirtueTileAddon( m_CompassionTileType ); } }
+		public override int LabelNumber { get { return 1080481; } } // Compassion Virtue Tile Deed
+
+		private CompassionTileType m_CompassionTileType;
+
+		[Constructable]
+		public CompassionVirtueTileDeed()
+		{
+			LootType = LootType.Blessed;
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( IsChildOf( from.Backpack ) )
+			{
+				from.CloseGump( typeof( RewardOptionGump ) );
+				from.SendGump( new RewardOptionGump( this ) );
+			}
+			else
+				from.SendLocalizedMessage( 1062334 ); // This item must be in your backpack to be used.       	
+		}
+
+		public CompassionVirtueTileDeed( 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();
+        }
+
+		public void GetOptions( RewardOptionList list )
+		{
+			list.Add( (int) CompassionTileType.North, 1080218 );
+			list.Add( (int) CompassionTileType.West, 1080217 );
+		}
+
+
+		public void OnOptionSelected( Mobile from, int choice )
+		{
+			m_CompassionTileType = (CompassionTileType) choice;
+
+			if ( !Deleted )
+				base.OnDoubleClick( from );
+		}
+	}
+}

Scripts/Services/CleanUpBritannia/Items/DragonHead.cs

@@ -0,0 +1,329 @@
+using System;
+using Server.Gumps;
+using Server.Multis;
+using Server.Network;
+using Server.Targeting;
+
+namespace Server.Items
+{
+    public enum AddonFacing
+    {
+        South = 0,
+        East = 1,
+    }
+
+    public class DragonHeadAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new DragonHeadAddonDeed(); } }
+
+        public AddonFacing Facing { get; set; }
+
+        [Constructable]
+        public DragonHeadAddon()
+            : this(AddonFacing.South)
+        {
+        }
+
+        [Constructable]
+        public DragonHeadAddon(AddonFacing facing)
+        {
+            Facing = facing;
+
+            switch (facing)
+            {
+                case AddonFacing.South:
+                    AddComponent(new DragonHeadComponent(0x2234), 0, 0, 10);
+                    break;
+                case AddonFacing.East:
+                    AddComponent(new DragonHeadComponent(0x2235), 0, 0, 10);
+                    break;
+
+            }
+        }
+
+        private class DragonHeadComponent : AddonComponent
+        {
+            public override bool NeedsWall { get { return true; } }
+            public override Point3D WallPosition
+            {
+                get
+                {
+                    switch (ItemID)
+                    {
+                        default:
+                        case 0x2234: return new Point3D(0, -1, 0);
+                        case 0x2235: return new Point3D(-1, 0, 0);
+                    }
+                }
+            }
+
+            public DragonHeadComponent(int id)
+                : base(id)
+            {
+            }
+
+            public DragonHeadComponent(Serial serial)
+                : base(serial)
+            {
+            }
+
+            public override void Serialize(GenericWriter writer)
+            {
+                base.Serialize(writer);
+
+                writer.WriteEncodedInt(0); // version
+            }
+
+            public override void Deserialize(GenericReader reader)
+            {
+                base.Deserialize(reader);
+
+                int version = reader.ReadEncodedInt();
+            }
+        }
+
+        public DragonHeadAddon(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+    }
+
+    public class DragonHeadAddonDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new DragonHeadAddon(Facing); } }
+
+        private AddonFacing Facing { get; set; }
+
+        public override int LabelNumber { get { return 1080209; } } // Dragon Head
+
+        [Constructable]
+        public DragonHeadAddonDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public DragonHeadAddonDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)AddonFacing.South, 1080208);
+            list.Add((int)AddonFacing.East, 1080207);
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            Facing = (AddonFacing)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+
+    // old classes
+    [TypeAlias("Server.Items.DragonHead")]
+    public class DragonHeadOld : Item, IAddon
+    {
+        public override bool IsArtifact { get { return true; } }
+
+        [Constructable]
+        public DragonHeadOld()
+            : this(0x2234)
+        {
+        }
+
+        [Constructable]
+        public DragonHeadOld(int itemID)
+            : base(itemID)
+        {
+            Movable = false;
+        }
+
+        public DragonHeadOld(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool ForceShowProperties
+        {
+            get
+            {
+                return ObjectPropertyList.Enabled;
+            }
+        }
+        public Item Deed
+        {
+            get
+            {
+                return new DragonHeadAddonDeed();
+            }
+        }
+        public bool FacingEast
+        {
+            get
+            {
+                return ItemID == 0x2235;
+            }
+        }
+
+        void IChopable.OnChop(Mobile user)
+        {
+            OnDoubleClick(user);
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (from.InRange(Location, 2))
+            {
+                BaseHouse house = BaseHouse.FindHouseAt(this);
+
+                if (house != null && house.IsOwner(from))
+                {
+                    from.CloseGump(typeof(RewardDemolitionGump));
+                    from.SendGump(new RewardDemolitionGump(this, 1049783)); // Do you wish to re-deed this decoration?
+                }
+                else
+                    from.SendLocalizedMessage(1049784); // You can only re-deed this decoration if you are the house owner or originally placed the decoration.
+            }
+            else
+                from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1019045); // I can't reach that.
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+
+        public bool CouldFit(IPoint3D p, Map map)
+        {
+            if (map == null || !map.CanFit(p.X, p.Y, p.Z, ItemData.Height))
+                return false;
+
+            if (FacingEast)
+                return BaseAddon.IsWall(p.X - 1, p.Y, p.Z, map); // west wall                
+            else
+                return BaseAddon.IsWall(p.X, p.Y - 1, p.Z, map); // north wall
+        }
+    }
+
+    [TypeAlias("Server.Items.DragonHeadDeed")]
+    public class DragonHeadDeedOld : Item
+    {
+        public override int LabelNumber { get { return 1028756; } } // dragon head
+
+        [Constructable]
+        public DragonHeadDeedOld()
+            : base(0x14F0)
+        {
+            LootType = LootType.Blessed;
+            Weight = 1.0;
+        }
+
+        public DragonHeadDeedOld(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+
+            Timer.DelayCall(TimeSpan.FromSeconds(10), Replace);
+        }
+
+        private void Replace()
+        {
+            Container c = Parent as Container;
+
+            if (c != null)
+            {
+                var deed = new DragonHeadAddonDeed();
+                c.DropItem(deed);
+            }
+            else if (Parent == null)
+            {
+                Server.Multis.BaseHouse house = Server.Multis.BaseHouse.FindHouseAt(this);
+
+                var deed = new DragonHeadAddonDeed();
+                deed.MoveToWorld(Location, Map);
+
+                deed.IsLockedDown = IsLockedDown;
+                deed.IsSecure = IsSecure;
+                deed.Movable = Movable;
+
+                if (house != null && house.LockDowns.ContainsKey(this))
+                {
+                    house.LockDowns.Remove(this);
+                    house.LockDowns.Add(deed, house.Owner);
+                }
+                else if (house != null && house.IsSecure(this))
+                {
+                    house.ReleaseSecure(house.Owner, this);
+                    house.AddSecure(house.Owner, deed);
+                }
+            }
+
+            Delete();
+        }
+    }
+}

Scripts/Services/CleanUpBritannia/Items/DuelistsEdge.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class DuelistsEdge : BaseTalisman
+    {
+		public override bool IsArtifact { get { return true; } }
+		
+        [Constructable]
+        public DuelistsEdge()
+            : base(0x2F58)
+        {
+            this.Hue = 1902;
+            this.SkillBonuses.SetValues(0, SkillName.Anatomy, 10.0);
+            this.Attributes.RegenStam = 2;
+            this.Attributes.AttackChance = 5;
+            this.Attributes.WeaponDamage = 20;
+        }
+
+        public DuelistsEdge(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1154727;
+            }
+        }// Duelist's Edge
+        public override bool ForceShowName
+        {
+            get
+            {
+                return true;
+            }
+        }
+        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/Services/CleanUpBritannia/Items/FirePit.cs

@@ -0,0 +1,66 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class FirePitAddon : BaseAddon
+	{
+		public override BaseAddonDeed Deed { get { return new FirePitDeed(); } }
+
+		[Constructable]
+		public FirePitAddon()
+		{
+			AddComponent( new AddonComponent( 10749 ), 0, 0, 0 );
+		}
+
+		public FirePitAddon( 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();
+        }
+	}
+
+	public class FirePitDeed : BaseAddonDeed
+	{
+		public override BaseAddon Addon { get { return new FirePitAddon(); } }
+		public override int LabelNumber { get { return 1080206; } } // Fire Pit
+
+		[Constructable]
+		public FirePitDeed()
+		{
+			LootType = LootType.Blessed;
+		}
+
+		public FirePitDeed( 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/Services/CleanUpBritannia/Items/FootedChestOfDrawers.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Server.Items
+{
+    [Furniture]
+    [Flipable(0x0A30, 0x0A38)]
+    public class FootedChestOfDrawers : LockableContainer
+    {
+        [Constructable]
+        public FootedChestOfDrawers()
+            : base(0x0A30)
+        {
+            this.Weight = 25.0;
+        }
+
+        public FootedChestOfDrawers(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int DefaultGumpID
+        {
+            get
+            {
+                return 0x48;
+            }
+        }
+        public override int DefaultDropSound
+        {
+            get
+            {
+                return 0x42;
+            }
+        }
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1151221;
+            }
+        }// footed chest of drawers
+
+        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/Services/CleanUpBritannia/Items/HonestyVirtueTile.cs

@@ -0,0 +1,117 @@
+using System;
+using Server;
+using Server.Gumps;
+
+namespace Server.Items
+{
+	public enum HonestyTileType
+	{
+		North = 0,
+		West = 1,
+	}
+
+	public class HonestyVirtueTileAddon : BaseAddon
+	{
+		public override BaseAddonDeed Deed { get { return new HonestyVirtueTileDeed(); } }
+
+		private HonestyTileType m_HonestyTileType;
+
+		private int offset;
+
+		[Constructable]
+		public HonestyVirtueTileAddon( HonestyTileType type )
+		{
+			m_HonestyTileType = type;
+
+			offset = 0;
+
+			if ( type == HonestyTileType.North )
+			{
+				offset = 4;
+			}
+
+			AddComponent( new AddonComponent( 5279 + offset ), 0, 0, 0 );
+			AddComponent( new AddonComponent( 5280 + offset ), 0, 1, 0 );
+			AddComponent( new AddonComponent( 5281 + offset ), 1, 1, 0 );
+			AddComponent( new AddonComponent( 5282 + offset ), 1, 0, 0 );
+		}
+
+		public HonestyVirtueTileAddon( 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();
+        }
+	}
+
+	public class HonestyVirtueTileDeed : BaseAddonDeed, IRewardOption
+	{
+		public override BaseAddon Addon { get { return new HonestyVirtueTileAddon( m_HonestyTileType ); } }
+		public override int LabelNumber { get { return 1080488; } } // Honesty Virtue Tile Deed
+
+		private HonestyTileType m_HonestyTileType;
+
+		[Constructable]
+		public HonestyVirtueTileDeed()
+		{
+			LootType = LootType.Blessed;
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( IsChildOf( from.Backpack ) )
+			{
+				from.CloseGump( typeof( RewardOptionGump ) );
+				from.SendGump( new RewardOptionGump( this ) );
+			}
+			else
+				from.SendLocalizedMessage( 1062334 ); // This item must be in your backpack to be used.       	
+		}
+
+		public HonestyVirtueTileDeed( 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();
+        }
+
+		public void GetOptions( RewardOptionList list )
+		{
+			list.Add( (int) HonestyTileType.North, 1080215 );
+			list.Add( (int) HonestyTileType.West, 1080214 );
+		}
+
+
+		public void OnOptionSelected( Mobile from, int choice )
+		{
+			m_HonestyTileType = (HonestyTileType) choice;
+
+			if ( !Deleted )
+				base.OnDoubleClick( from );
+		}
+	}
+}

Scripts/Services/CleanUpBritannia/Items/HonorVirtueTile.cs

@@ -0,0 +1,117 @@
+using System;
+using Server;
+using Server.Gumps;
+
+namespace Server.Items
+{
+	public enum HonorTileType
+	{
+		North = 0,
+		West = 1,
+	}
+
+	public class HonorVirtueTileAddon : BaseAddon
+	{
+		public override BaseAddonDeed Deed { get { return new HonorVirtueTileDeed(); } }
+
+		private HonorTileType m_HonorTileType;
+
+		private int offset;
+
+		[Constructable]
+		public HonorVirtueTileAddon( HonorTileType type )
+		{
+			m_HonorTileType = type;
+
+			offset = 0;
+
+			if ( type == HonorTileType.North )
+			{
+				offset = 4;
+			}
+
+			AddComponent( new AddonComponent( 5319 + offset ), 0, 0, 0 );
+			AddComponent( new AddonComponent( 5320 + offset ), 0, 1, 0 );
+			AddComponent( new AddonComponent( 5321 + offset ), 1, 1, 0 );
+			AddComponent( new AddonComponent( 5322 + offset ), 1, 0, 0 );
+		}
+
+		public HonorVirtueTileAddon( 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();
+        }
+	}
+
+	public class HonorVirtueTileDeed : BaseAddonDeed, IRewardOption
+	{
+		public override BaseAddon Addon { get { return new HonorVirtueTileAddon( m_HonorTileType ); } }
+		public override int LabelNumber { get { return 1080485; } } // Honor Virtue Tile Deed
+
+		private HonorTileType m_HonorTileType;
+
+		[Constructable]
+		public HonorVirtueTileDeed()
+		{
+			LootType = LootType.Blessed;
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( IsChildOf( from.Backpack ) )
+			{
+				from.CloseGump( typeof( RewardOptionGump ) );
+				from.SendGump( new RewardOptionGump( this ) );
+			}
+			else
+				from.SendLocalizedMessage( 1062334 ); // This item must be in your backpack to be used.       	
+		}
+
+		public HonorVirtueTileDeed( 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();
+        }
+
+		public void GetOptions( RewardOptionList list )
+		{
+			list.Add( (int) HonorTileType.North, 1080230 );
+			list.Add( (int) HonorTileType.West, 1080229 );
+		}
+
+
+		public void OnOptionSelected( Mobile from, int choice )
+		{
+			m_HonorTileType = (HonorTileType) choice;
+
+			if ( !Deleted )
+				base.OnDoubleClick( from );
+		}
+	}
+}

Scripts/Services/CleanUpBritannia/Items/HorseBarding.cs

@@ -0,0 +1,117 @@
+using System;
+using Server;
+using Server.Gumps;
+
+namespace Server.Items
+{
+	public enum HorseBardingType
+	{
+		South = 0,
+		East = 1,
+	}
+
+	public class HorseBardingAddon : BaseAddon
+	{
+		public override BaseAddonDeed Deed { get { return new HorseBardingDeed(); } }
+
+		private HorseBardingType m_HorseBardingType;
+
+		[Constructable]
+		public HorseBardingAddon( HorseBardingType type )
+		{
+			m_HorseBardingType = type;
+
+			switch ( type )
+			{
+				case HorseBardingType.South:
+					AddComponent( new AddonComponent( 4984 ), 0, 0, 0 );
+					AddComponent( new AddonComponent( 4985 ), 0, -1, 0 );
+					break;
+				case HorseBardingType.East:
+					AddComponent( new AddonComponent( 4983 ), 0, 0, 0 );
+					AddComponent( new AddonComponent( 4982 ), -1, 0, 0 );
+					break;
+
+			}
+		}
+
+		public HorseBardingAddon( 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();
+        }
+	}
+
+	public class HorseBardingDeed : BaseAddonDeed, IRewardOption
+	{
+		public override BaseAddon Addon { get { return new HorseBardingAddon( m_HorseBardingType ); } }
+
+		private HorseBardingType m_HorseBardingType;
+
+		public override int LabelNumber { get { return 1080212; } } // Horse Barding
+
+		[Constructable]
+		public HorseBardingDeed()
+		{
+			LootType = LootType.Blessed;
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( IsChildOf( from.Backpack ) )
+			{
+				from.CloseGump( typeof( RewardOptionGump ) );
+				from.SendGump( new RewardOptionGump( this ) );
+			}
+			else
+				from.SendLocalizedMessage( 1062334 ); // This item must be in your backpack to be used.       	
+		}
+
+		public HorseBardingDeed( 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();
+        }
+
+		public void GetOptions( RewardOptionList list )
+		{
+			list.Add( (int) HorseBardingType.South, 1080211 );
+			list.Add( (int) HorseBardingType.East, 1080210 );
+		}
+
+
+		public void OnOptionSelected( Mobile from, int choice )
+		{
+			m_HorseBardingType = (HorseBardingType) choice;
+
+			if ( !Deleted )
+				base.OnDoubleClick( from );
+		}
+	}
+}

Scripts/Services/CleanUpBritannia/Items/HumilityVirtueTile.cs

@@ -0,0 +1,116 @@
+using System;
+using Server;
+using Server.Gumps;
+
+namespace Server.Items
+{
+	public enum HumilityTileType
+	{
+		North = 0,
+		West = 1,
+	}
+
+	public class HumilityVirtueTileAddon : BaseAddon
+	{
+		public override BaseAddonDeed Deed { get { return new HumilityVirtueTileDeed(); } }
+
+		private HumilityTileType m_HumilityTileType;
+
+		private int offset;
+
+		[Constructable]
+		public HumilityVirtueTileAddon( HumilityTileType type )
+		{
+			m_HumilityTileType = type;
+
+			offset = 0;
+
+			if ( type == HumilityTileType.North )
+			{
+				offset = 4;
+			}
+
+			AddComponent( new AddonComponent( 5327 + offset ), 0, 0, 0 );
+			AddComponent( new AddonComponent( 5328 + offset ), 0, 1, 0 );
+			AddComponent( new AddonComponent( 5329 + offset ), 1, 1, 0 );
+			AddComponent( new AddonComponent( 5330 + offset ), 1, 0, 0 );
+		}
+
+		public HumilityVirtueTileAddon( 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();
+        }
+	}
+
+	public class HumilityVirtueTileDeed : BaseAddonDeed, IRewardOption
+	{
+		public override BaseAddon Addon { get { return new HumilityVirtueTileAddon( m_HumilityTileType ); } }
+		public override int LabelNumber { get { return 1080483; } } // Humility Virtue Tile Deed
+
+		private HumilityTileType m_HumilityTileType;
+
+		[Constructable]
+		public HumilityVirtueTileDeed()
+		{
+			LootType = LootType.Blessed;
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			if ( IsChildOf( from.Backpack ) )
+			{
+				from.CloseGump( typeof( RewardOptionGump ) );
+				from.SendGump( new RewardOptionGump( this ) );
+			}
+			else
+				from.SendLocalizedMessage( 1062334 ); // This item must be in your backpack to be used.       	
+		}
+
+		public HumilityVirtueTileDeed( 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();
+        }
+
+		public void GetOptions( RewardOptionList list )
+		{
+			list.Add( (int) HumilityTileType.North, 1080233 );
+			list.Add( (int) HumilityTileType.West, 1080232 );
+		}
+
+		public void OnOptionSelected( Mobile from, int choice )
+		{
+			m_HumilityTileType = (HumilityTileType) choice;
+
+			if ( !Deleted )
+				base.OnDoubleClick( from );
+		}
+	}
+}

Scripts/Services/CleanUpBritannia/Items/JusticeVirtueTile.cs

@@ -0,0 +1,117 @@
+using System;
+using Server;
+using Server.Gumps;
+
+namespace Server.Items
+{
+    public enum JusticeTileType
+    {
+        North = 0,
+        West = 1,
+    }
+
+    public class JusticeVirtueTileAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new JusticeVirtueTileDeed(); } }
+
+        private JusticeTileType m_JusticeTileType;
+
+        private int offset;
+
+        [Constructable]
+        public JusticeVirtueTileAddon(JusticeTileType type)
+        {
+            m_JusticeTileType = type;
+
+            offset = 0;
+
+            if (type == JusticeTileType.North)
+            {
+                offset = 4;
+            }
+
+            AddComponent(new AddonComponent(5295 + offset), 0, 0, 0);
+            AddComponent(new AddonComponent(5296 + offset), 0, 1, 0);
+            AddComponent(new AddonComponent(5297 + offset), 1, 1, 0);
+            AddComponent(new AddonComponent(5298 + offset), 1, 0, 0);
+        }
+
+        public JusticeVirtueTileAddon(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();
+        }
+    }
+
+    public class JusticeVirtueTileDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new JusticeVirtueTileAddon(m_JusticeTileType); } }
+        public override int LabelNumber { get { return 1080487; } } // Justice Virtue Tile Deed
+
+        private JusticeTileType m_JusticeTileType;
+
+        [Constructable]
+        public JusticeVirtueTileDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public JusticeVirtueTileDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)JusticeTileType.North, 1080221);
+            list.Add((int)JusticeTileType.West, 1080220);
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            m_JusticeTileType = (JusticeTileType)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+}

Scripts/Services/CleanUpBritannia/Items/LillyPad.cs

@@ -0,0 +1,34 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+    public class LillyPad : Item
+    {
+        [Constructable]
+        public LillyPad()
+            : base(0xDBC)
+        {
+            Weight = 1.0;
+        }
+
+        public LillyPad(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/Services/CleanUpBritannia/Items/LillyPads.cs

@@ -0,0 +1,34 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+    public class LillyPads : Item
+    {
+        [Constructable]
+        public LillyPads()
+            : base(0xDBE)
+        {
+            Weight = 1.0;
+        }
+
+        public LillyPads(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/Services/CleanUpBritannia/Items/LuckyCharm.cs

@@ -0,0 +1,40 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class LuckyCharm : BaseTalisman
+    {
+		public override int LabelNumber { get { return 1154725; } }// Lucky Charm
+		public override bool IsArtifact { get { return true; } }
+		
+        [Constructable]
+        public LuckyCharm()
+            : base(0x2F5B)
+        {
+            Hue = 1923;
+            Attributes.RegenHits = 1;
+            Attributes.RegenStam = 1;
+            Attributes.RegenMana = 1;
+            Attributes.Luck = 150;
+        }
+
+        public LuckyCharm(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/Services/CleanUpBritannia/Items/Mailbox.cs

@@ -0,0 +1,295 @@
+using System;
+using System.Collections.Generic;
+using Server.Multis;
+using Server.ContextMenus;
+using Server.Network;
+using System.Linq;
+
+namespace Server.Items
+{
+    [Furniture]
+    public class Mailbox : LockableContainer, IFlipable
+    {
+        public override int LabelNumber { get { return 1113927; } } // Mailbox
+
+        public override int DefaultGumpID { get { return 0x11A; } }
+
+        public virtual int SouthMailBoxID { get { return 0x4141; } }
+        public virtual int SouthEmptyMailBoxID { get { return 0x4142; } }
+        public virtual int EastMailBoxID { get { return 0x4143; } }
+        public virtual int EastEmptyMailBoxID { get { return 0x4144; } }
+
+        public Dictionary<Item, Mobile> Contents { get; set; }
+
+        public bool IsEmpty { get { return Items.Count == 0; } }
+
+        [CommandProperty(AccessLevel.Decorator)]
+        public override int ItemID
+        {
+            get { return base.ItemID; }
+            set
+            {
+                base.ItemID = value;
+
+                CheckMailBox();
+            }
+        }
+
+        public void CheckMailBox()
+        {
+            if (IsEmpty)
+            {
+                if (ItemID == SouthMailBoxID)
+                {
+                    base.ItemID = SouthEmptyMailBoxID;
+                }
+                else if (ItemID == EastMailBoxID)
+                {
+                    base.ItemID = EastEmptyMailBoxID;
+                }
+            }
+            else
+            {
+                if (ItemID == SouthEmptyMailBoxID)
+                {
+                    base.ItemID = SouthMailBoxID;
+                }
+                else if (ItemID == EastEmptyMailBoxID)
+                {
+                    base.ItemID = EastMailBoxID;
+                }
+            }
+        }
+
+        [Constructable]
+        public Mailbox()
+            : this(0x4142)
+        {
+        }
+
+        [Constructable]
+        public Mailbox(int id)
+            : base(id)
+        {
+            Weight = 5.0;
+        }
+
+        public virtual void OnFlip(Mobile from)
+        {
+            if (ItemID == SouthMailBoxID)
+            {
+                base.ItemID = EastMailBoxID;
+            }
+            else if (ItemID == EastMailBoxID)
+            {
+                base.ItemID = SouthMailBoxID;
+            }
+            else if (ItemID == SouthEmptyMailBoxID)
+            {
+                base.ItemID = EastEmptyMailBoxID;
+            }
+            else if (ItemID == EastEmptyMailBoxID)
+            {
+                base.ItemID = SouthEmptyMailBoxID;
+            }
+        }
+
+        public override void GetChildProperties(ObjectPropertyList list, Item item)
+        {
+            base.GetChildProperties(list, item);
+
+            if (Contents != null && Contents.ContainsKey(item))
+            {
+                list.Add(1113938, Contents[item] != null ? Contents[item].Name : "Unknown");
+            }
+        }
+
+        public override void GetChildContextMenuEntries(Mobile from, List<ContextMenuEntry> list, Item item)
+        {
+            base.GetChildContextMenuEntries(from, list, item);
+        }
+
+        public override bool OnDragDropInto(Mobile from, Item item, Point3D p)
+        {
+            bool dropped = base.OnDragDropInto(from, item, p);
+            BaseHouse house = BaseHouse.FindHouseAt(this);
+
+            if (house != null && dropped)
+            {
+                OnItemDropped(from, item, house);
+            }
+
+            return dropped;
+        }
+
+        public override bool TryDropItem(Mobile from, Item dropped, bool sendFullMessage)
+        {
+            if (!CheckHold(from, dropped, true, true))
+            {
+                return false;
+            }
+
+            BaseHouse house = BaseHouse.FindHouseAt(this);
+
+            if (house != null && IsLockedDown)
+            {
+                if (!house.CheckAccessibility(this, from))
+                {
+                    PrivateOverheadMessage(MessageType.Regular, 0x21, 1061637, from.NetState); // You are not allowed to access this!
+                    from.SendLocalizedMessage(501727); // You cannot lock that down!
+                    return false;
+                }
+            }
+
+            DropItem(dropped);
+
+            if (house != null && !IsLockedDown)
+            {
+                OnItemDropped(from, dropped, house);
+            }
+
+            return true;
+        }
+
+        public override bool IsAccessibleTo(Mobile m)
+        {
+            return true;
+        }
+
+        public override bool CheckLift(Mobile from, Item item, ref LRReason reject)
+        {
+            if (item == this)
+            {
+                return base.CheckLift(from, item, ref reject);
+            }
+
+            BaseHouse house = BaseHouse.FindHouseAt(this);
+
+            if (house != null && IsSecure)
+            {
+                var secure = house.GetSecureInfoFor(this);
+
+                return secure != null && house.HasSecureAccess(from, secure);
+            }
+
+            return base.CheckLift(from, item, ref reject);
+        }
+
+        public override void SendFullItemsMessage(Mobile to, Item item) // That mailbox is completely full.
+        {
+            to.SendLocalizedMessage(1113940);  // That mailbox is completely full.
+        }
+
+        public virtual void OnItemDropped(Mobile from, Item item, BaseHouse house)
+        {
+            var secure = house.GetSecureInfoFor(this);
+
+            if (secure != null && !house.HasSecureAccess(from, secure))
+            {
+                if (Contents == null)
+                    Contents = new Dictionary<Item, Mobile>();
+
+                Contents[item] = from;
+                item.InvalidateProperties();
+            }
+        }
+
+        public override void OnItemAdded(Item item)
+        {
+            base.OnItemAdded(item);
+
+            CheckMailBox();
+        }
+
+        public override void OnItemRemoved(Item item)
+        {
+            base.OnItemRemoved(item);
+
+            CheckMailBox();
+
+            if (Contents != null && Contents.ContainsKey(item))
+            {
+                Contents.Remove(item);
+
+                if (Contents.Count == 0)
+                {
+                    Contents = null;
+                }
+            }
+        }
+
+        public override void Open(Mobile from)
+        {
+            Defrag();
+            DisplayTo(from);
+        }
+
+        private void Defrag()
+        {
+            if (Contents == null)
+                return;
+
+            var remove = Contents.Keys.Where(k => k.Deleted || !Items.Contains(k)).ToList();
+
+            foreach (var item in remove)
+            {
+                Contents.Remove(item);
+            }
+
+            ColUtility.Free(remove);
+        }
+
+        public Mailbox(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1);
+
+            writer.Write(Contents == null ? 0 : Contents.Count);
+
+            if (Contents != null)
+            {
+                foreach (var kvp in Contents)
+                {
+                    writer.Write(kvp.Key);
+                    writer.Write(kvp.Value);
+                }
+            }
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch (version)
+            {
+                case 1:
+                    {
+                        int count = reader.ReadInt();
+
+                        for (int i = 0; i < count; i++)
+                        {
+                            Item item = reader.ReadItem();
+                            Mobile m = reader.ReadMobile();
+
+                            if (m != null && item != null)
+                            {
+                                if (Contents == null)
+                                    Contents = new Dictionary<Item, Mobile>();
+
+                                Contents[item] = m;
+                            }
+                        }
+                        break;
+                    }
+            }
+        }
+    }
+}

Scripts/Services/CleanUpBritannia/Items/Mushrooms.cs

@@ -0,0 +1,121 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+    public class Mushrooms1 : Item
+    {
+        [Constructable]
+        public Mushrooms1()
+            : base(0x0D0F)
+        {
+            Weight = 1.0;
+        }
+
+        public Mushrooms1(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();
+        }
+    }
+
+    public class Mushrooms2 : Item
+    {
+        [Constructable]
+        public Mushrooms2()
+            : base(0x0D12)
+        {
+            Weight = 1.0;
+        }
+
+        public Mushrooms2(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();
+        }
+    }
+
+    public class Mushrooms3 : Item
+    {
+        [Constructable]
+        public Mushrooms3()
+            : base(0x0D10)
+        {
+            Weight = 1.0;
+        }
+
+        public Mushrooms3(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();
+        }
+    }
+
+    public class Mushrooms4 : Item
+    {
+        [Constructable]
+        public Mushrooms4()
+            : base(0x0D13)
+        {
+            Weight = 1.0;
+        }
+
+        public Mushrooms4(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/Services/CleanUpBritannia/Items/MysticsMemento.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class MysticsMemento : BaseTalisman
+    {
+		public override bool IsArtifact { get { return true; } }
+		
+        [Constructable]
+        public MysticsMemento()
+            : base(0x2F5B)
+        {
+            this.Hue = 1912;
+            this.SkillBonuses.SetValues(0, SkillName.Focus, 10.0);
+            this.Attributes.RegenMana = 1;
+            this.Attributes.LowerRegCost = 10;
+            this.Attributes.SpellDamage = 5;
+        }
+
+        public MysticsMemento(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1154730;
+            }
+        }// Mystic's Memento
+        public override bool ForceShowName
+        {
+            get
+            {
+                return true;
+            }
+        }
+        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/Services/CleanUpBritannia/Items/NamedRobes.cs

@@ -0,0 +1,161 @@
+using System;
+using Server;
+using Server.Gumps;
+
+namespace Server.Items
+{
+    public class HumansAndElvesRobe : Robe
+    {
+        public override int LabelNumber { get { return 1151202; } } // Humans & Elves are our friends!
+
+        [Constructable]
+        public HumansAndElvesRobe()
+        {
+            LootType = LootType.Blessed;
+            Hue = Utility.RandomDyedHue();
+        }
+
+        public HumansAndElvesRobe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GargoylesAreOurFriendsRobe : Robe
+    {
+        public override int LabelNumber { get { return 1151203; } } // Gargoyles are our friends!
+
+        [Constructable]
+        public GargoylesAreOurFriendsRobe()
+        {
+            LootType = LootType.Blessed;
+            Hue = Utility.RandomDyedHue();
+        }
+
+        public GargoylesAreOurFriendsRobe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class WeArePiratesRobe : Robe
+    {
+        public override int LabelNumber { get { return 1151204; } } // We are pirates!
+
+        [Constructable]
+        public WeArePiratesRobe()
+        {
+            LootType = LootType.Blessed;
+            Hue = Utility.RandomDyedHue();
+        }
+
+        public WeArePiratesRobe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FollowerOfBaneRobe : Robe
+    {
+        public override int LabelNumber { get { return 1151205; } } // Follower of Bane
+
+        [Constructable]
+        public FollowerOfBaneRobe()
+        {
+            LootType = LootType.Blessed;
+            Hue = Utility.RandomDyedHue();
+        }
+
+        public FollowerOfBaneRobe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class QueenDawnForeverRobe : Robe
+    {
+        public override int LabelNumber { get { return 1151206; } } // Queen Dawn Forever
+
+        [Constructable]
+        public QueenDawnForeverRobe()
+        {
+            LootType = LootType.Blessed;
+            Hue = Utility.RandomDyedHue();
+        }
+
+        public QueenDawnForeverRobe(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/CleanUpBritannia/Items/NaturesTears.cs

@@ -0,0 +1,57 @@
+using System;
+
+namespace Server.Items
+{
+    public class NaturesTears : BaseInstrument
+    {
+        [Constructable]
+        public NaturesTears()
+        {
+            this.Hue = 2075;
+            this.Weight = 5;
+            this.Slayer = SlayerName.Fey;
+
+            UsesRemaining = 450;
+        }
+
+        public NaturesTears(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1154373;
+            }
+        }// Nature's Tears
+        public override int InitMinUses
+        {
+            get
+            {
+                return 450;
+            }
+        }
+        public override int InitMaxUses
+        {
+            get
+            {
+                return 450;
+            }
+        }
+        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/Services/CleanUpBritannia/Items/NecromancersPhylactery.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class NecromancersPhylactery : BaseTalisman
+    {
+		public override bool IsArtifact { get { return true; } }
+		
+        [Constructable]
+        public NecromancersPhylactery()
+            : base(0x2F5A)
+        {
+            this.Hue = 1912;
+            this.SkillBonuses.SetValues(0, SkillName.SpiritSpeak, 10.0);
+            this.Attributes.RegenMana = 1;
+            this.Attributes.LowerRegCost = 10;
+            this.Attributes.SpellDamage = 5;
+        }
+
+        public NecromancersPhylactery(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1154728;
+            }
+        }// Necromancer's Phylactery
+        public override bool ForceShowName
+        {
+            get
+            {
+                return true;
+            }
+        }
+        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/Services/CleanUpBritannia/Items/NestWithEggs.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace Server.Items
+{
+    public class NestWithEggs : Item
+    {
+        [Constructable]
+        public NestWithEggs()
+            : base(0x1AD4)
+        {
+            this.Hue = 2415;
+            this.Weight = 2;
+        }
+
+        public NestWithEggs(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1026868;
+            }
+        }// nest with eggs
+        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/Services/CleanUpBritannia/Items/NocturneEarrings.cs

@@ -0,0 +1,37 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class NocturneEarrings : SilverEarrings
+    {
+        public override int LabelNumber { get { return 1080189; } } // Nocturne Earrings
+
+        [Constructable]
+        public NocturneEarrings()
+        {
+            Hue = 0x3E5;
+            Attributes.NightSight = 1;
+        }
+
+        public NocturneEarrings(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+        }
+    }
+}

Scripts/Services/CleanUpBritannia/Items/OrnateElvenTapestry.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x2D71, 0x2D72)]
+    public class OrnateElvenTapestry : Item
+    {
+        [Constructable]
+        public OrnateElvenTapestry()
+            : base(0x2D72)
+        {
+            this.Weight = 1;
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1031633;
+            }
+        }// ornate elven tapestry
+
+        public OrnateElvenTapestry(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/Services/CleanUpBritannia/Items/Pigments/CleanupPigments.cs

@@ -0,0 +1,679 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Server.Items
+{
+    public class IntenseTealPigment : CompassionPigment
+    {
+        [Constructable]
+        public IntenseTealPigment()
+            : base(CompassionPigmentType.IntenseTeal)
+        {
+        }
+
+        public IntenseTealPigment(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();            
+        }
+    }
+
+    public class TyrianPurplePigment : CompassionPigment
+    {
+        [Constructable]
+        public TyrianPurplePigment()
+            : base(CompassionPigmentType.TyrianPurple)
+        {
+        }
+
+        public TyrianPurplePigment(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();
+        }
+    }
+
+    public class MottledSunsetBluePigment : CompassionPigment
+    {
+        [Constructable]
+        public MottledSunsetBluePigment()
+            : base(CompassionPigmentType.MottledSunsetBlue)
+        {
+        }
+
+        public MottledSunsetBluePigment(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();
+        }
+    }
+
+    public class MossyGreenPigment : CompassionPigment
+    {
+        [Constructable]
+        public MossyGreenPigment()
+            : base(CompassionPigmentType.MossyGreen)
+        {
+        }
+
+        public MossyGreenPigment(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();
+        }
+    }
+
+    public class VibrantOcherPigment : CompassionPigment
+    {
+        [Constructable]
+        public VibrantOcherPigment()
+            : base(CompassionPigmentType.VibrantOcher)
+        {
+        }
+
+        public VibrantOcherPigment(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();
+        }
+    }
+
+    public class OliveGreenPigment : CompassionPigment
+    {
+        [Constructable]
+        public OliveGreenPigment()
+            : base(CompassionPigmentType.OliveGreen)
+        {
+        }
+
+        public OliveGreenPigment(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();
+        }
+    }
+
+    public class PolishedBronzePigment : CompassionPigment
+    {
+        [Constructable]
+        public PolishedBronzePigment()
+            : base(CompassionPigmentType.PolishedBronze)
+        {
+        }
+
+        public PolishedBronzePigment(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();
+        }
+    }
+
+    public class GlossyBluePigment : CompassionPigment
+    {
+        [Constructable]
+        public GlossyBluePigment()
+            : base(CompassionPigmentType.GlossyBlue)
+        {
+        }
+
+        public GlossyBluePigment(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();
+        }
+    }
+
+    public class BlackAndGreenPigment : CompassionPigment
+    {
+        [Constructable]
+        public BlackAndGreenPigment()
+            : base(CompassionPigmentType.BlackAndGreen)
+        {
+        }
+
+        public BlackAndGreenPigment(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();
+        }
+    }
+
+    public class DeepVioletPigment : CompassionPigment
+    {
+        [Constructable]
+        public DeepVioletPigment()
+            : base(CompassionPigmentType.DeepViolet)
+        {
+        }
+
+        public DeepVioletPigment(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();
+        }
+    }
+
+    public class AuraOfAmberPigment : CompassionPigment
+    {
+        [Constructable]
+        public AuraOfAmberPigment()
+            : base(CompassionPigmentType.AuraOfAmber)
+        {
+        }
+
+        public AuraOfAmberPigment(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();
+        }
+    }
+
+    public class MurkySeagreenPigment : CompassionPigment
+    {
+        [Constructable]
+        public MurkySeagreenPigment()
+            : base(CompassionPigmentType.MurkySeagreen)
+        {
+        }
+
+        public MurkySeagreenPigment(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();
+        }
+    }
+
+    public class ShadowyBluePigment : CompassionPigment
+    {
+        [Constructable]
+        public ShadowyBluePigment()
+            : base(CompassionPigmentType.ShadowyBlue)
+        {
+        }
+
+        public ShadowyBluePigment(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();
+        }
+    }
+
+    public class GleamingFuchsiaPigment : CompassionPigment
+    {
+        [Constructable]
+        public GleamingFuchsiaPigment()
+            : base(CompassionPigmentType.GleamingFuchsia)
+        {
+        }
+
+        public GleamingFuchsiaPigment(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();
+        }
+    }
+
+    public class GlossyFuchsiaPigment : CompassionPigment
+    {
+        [Constructable]
+        public GlossyFuchsiaPigment()
+            : base(CompassionPigmentType.GlossyFuchsia)
+        {
+        }
+
+        public GlossyFuchsiaPigment(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();
+        }
+    }
+
+    public class DeepBluePigment : CompassionPigment
+    {
+        [Constructable]
+        public DeepBluePigment()
+            : base(CompassionPigmentType.DeepBlue)
+        {
+        }
+
+        public DeepBluePigment(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();
+        }
+    }
+
+    public class VibranSeagreenPigment : CompassionPigment
+    {
+        [Constructable]
+        public VibranSeagreenPigment()
+            : base(CompassionPigmentType.VibranSeagreen)
+        {
+        }
+
+        public VibranSeagreenPigment(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();
+        }
+    }
+
+    public class MurkyAmberPigment : CompassionPigment
+    {
+        [Constructable]
+        public MurkyAmberPigment()
+            : base(CompassionPigmentType.MurkyAmber)
+        {
+        }
+
+        public MurkyAmberPigment(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();
+        }
+    }
+
+    public class VibrantCrimsonPigment : CompassionPigment
+    {
+        [Constructable]
+        public VibrantCrimsonPigment()
+            : base(CompassionPigmentType.VibrantCrimson)
+        {
+        }
+
+        public VibrantCrimsonPigment(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();
+        }
+    }
+
+    public class ReflectiveShadowPigment : CompassionPigment
+    {
+        [Constructable]
+        public ReflectiveShadowPigment()
+            : base(CompassionPigmentType.ReflectiveShadow)
+        {
+        }
+
+        public ReflectiveShadowPigment(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();
+        }
+    }
+
+    public class StarBluePigment : CompassionPigment
+    {
+        [Constructable]
+        public StarBluePigment()
+            : base(CompassionPigmentType.StarBlue)
+        {
+        }
+
+        public StarBluePigment(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();
+        }
+    }
+
+    public class MotherOfPearlPigment : CompassionPigment
+    {
+        [Constructable]
+        public MotherOfPearlPigment()
+            : base(CompassionPigmentType.MotherOfPearl)
+        {
+        }
+
+        public MotherOfPearlPigment(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();
+        }
+    }
+
+    public class LiquidSunshinePigment : CompassionPigment
+    {
+        [Constructable]
+        public LiquidSunshinePigment()
+            : base(CompassionPigmentType.LiquidSunshine)
+        {
+        }
+
+        public LiquidSunshinePigment(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();
+        }
+    }
+
+    public class DarkVoidPigment : CompassionPigment
+    {
+        [Constructable]
+        public DarkVoidPigment()
+            : base(CompassionPigmentType.DarkVoid)
+        {
+        }
+
+        public DarkVoidPigment(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/Services/CleanUpBritannia/Items/Pigments/CompassionPigment.cs

@@ -0,0 +1,256 @@
+using System;
+using Server;
+using Server.Targeting;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+	public enum CompassionPigmentType
+	{
+		PhoenixRed = 0,
+		AuraOfAmber,
+		DeepViolet,
+		PolishedBronze,
+		VibrantCrimson,
+		Lavender,
+		GleamingFuchsia,
+		DeepBlue,
+		GlossyFuchsia,
+		DarkVoid,
+		MurkySeagreen,
+		ReflectiveShadow,
+		LiquidSunshine,
+		ShadowyBlue,
+		BlackAndGreen,
+		GlossyBlue,
+		HunterGreen,
+		SlateBlue,
+		MotherOfPearl,
+		StarBlue,
+		MurkyAmber,
+		VibranSeagreen,
+        VibrantOcher,
+        MossyGreen,
+        OliveGreen,
+        MottledSunsetBlue,
+        TyrianPurple,
+        IntenseTeal
+	}
+
+	public class CompassionPigmentInfo
+	{
+		public CompassionPigmentType Type { get; private set; }
+		public int Hue { get; private set; }
+		public int LabelNumber { get; private set; }
+
+		public CompassionPigmentInfo( CompassionPigmentType type, int hue, int labelNumber )
+		{
+			Type = type;
+			Hue = hue;
+			LabelNumber = labelNumber;
+		}
+
+		public static CompassionPigmentInfo GetInfo( CompassionPigmentType type )
+		{
+			int v = (int) type;
+
+			if ( v < 0 || v >= m_Table.Length )
+				v = 0;
+
+			return m_Table[v];
+		}
+
+		private static CompassionPigmentInfo[] m_Table = new CompassionPigmentInfo[]
+		{
+			new CompassionPigmentInfo( CompassionPigmentType.PhoenixRed, 1964, 1151651 ), // Phoenix Red Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.AuraOfAmber, 1967, 1152308 ), // Aura of Amber Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.DeepViolet, 1929, 1151912 ), // Deep Violet Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.PolishedBronze, 1944, 1151909 ), // Polished Bronze Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.VibrantCrimson, 1964, 1153386 ), // Vibrant Crimson Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.Lavender, 1951, 1151650 ), // Lavender Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.GleamingFuchsia, 1930, 1152311 ), // Gleaming Fuchsia Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.DeepBlue, 1939, 1152348 ), // Deep Blue Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.GlossyFuchsia, 1919, 1152347 ), // Glossy Fuchsia Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.DarkVoid, 2068, 1154214 ), // Dark Void Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.MurkySeagreen, 1992, 1152309 ), // Murky Seagreen Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.ReflectiveShadow, 1910, 1153387 ), // Reflective Shadow Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.LiquidSunshine, 1923, 1154213 ), // Liquid Sunshine Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.ShadowyBlue, 1960, 1152310 ), // Shadowy Blue Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.BlackAndGreen, 1979, 1151911 ), // Black And Green Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.GlossyBlue, 1916, 1151910 ), // Glossy Blue Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.HunterGreen, 1936, 1151649 ), // Hunter Green Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.SlateBlue, 1983, 1151653 ), // Slate Blue Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.MotherOfPearl, 2720, 1154120 ), // Mother Of Pearl Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.StarBlue, 2723, 1154121 ), // Star Blue Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.MurkyAmber, 1989, 1152350 ), // Murky Amber Pigment
+			new CompassionPigmentInfo( CompassionPigmentType.VibranSeagreen, 1970, 1152349 ), // Vibran Seagreen Pigment
+            new CompassionPigmentInfo( CompassionPigmentType.VibrantOcher, 2725, 1154736 ), // Vibrant Ocher Pigment
+            new CompassionPigmentInfo( CompassionPigmentType.MossyGreen, 2684, 1154731 ), // Mossy Green Pigment
+            new CompassionPigmentInfo( CompassionPigmentType.OliveGreen, 2709, 1154733 ), // Olive Green Pigment
+            new CompassionPigmentInfo( CompassionPigmentType.MottledSunsetBlue, 2714, 1154734 ), // Mottled Sunset Blue Pigment
+            new CompassionPigmentInfo( CompassionPigmentType.TyrianPurple, 2716, 1154735 ), // Tyrian Purple Pigment
+            new CompassionPigmentInfo( CompassionPigmentType.IntenseTeal, 2691, 1154732 ), // Intense Teal Pigment
+        };
+	}
+
+	public class CompassionPigment : Item, IUsesRemaining
+	{
+		public override int LabelNumber
+		{
+			get
+			{
+				return CompassionPigmentInfo.GetInfo( m_Type ).LabelNumber;
+			}
+		}
+
+		private CompassionPigmentType m_Type;
+		private int m_UsesRemaining;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public CompassionPigmentType Type
+		{
+			get { return m_Type; }
+			set
+			{
+				m_Type = value;
+				InvalidateHue();
+			}
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public int UsesRemaining
+		{
+			get { return m_UsesRemaining; }
+			set
+			{
+				m_UsesRemaining = value;
+				InvalidateProperties();
+			}
+		}
+
+		public bool ShowUsesRemaining
+		{
+			get { return true; }
+			set
+			{
+			}
+		}
+
+		private void InvalidateHue()
+		{
+			Hue = CompassionPigmentInfo.GetInfo( m_Type ).Hue;
+		}
+
+		private static CompassionPigmentType GetRandomType()
+		{
+			var values = Enum.GetValues( typeof( CompassionPigmentType ) );
+			return (CompassionPigmentType) values.GetValue( Utility.Random( values.Length ) );
+		}
+
+		[Constructable]
+		public CompassionPigment()
+			: this( GetRandomType() )
+		{
+		}
+
+		[Constructable]
+		public CompassionPigment( CompassionPigmentType type )
+			: this( type, 5 )
+		{
+		}
+
+		[Constructable]
+		public CompassionPigment( CompassionPigmentType type, int uses )
+			: base( 0xEFF )
+		{
+			m_Type = type;
+			m_UsesRemaining = uses;
+
+			Weight = 1.0;
+
+			InvalidateHue();
+		}
+
+		public override void OnDoubleClick( Mobile from )
+		{
+			from.SendLocalizedMessage( 1070929 ); // Select the artifact or enhanced magic item to dye.
+
+			from.Target = new DyeTarget( this );
+		}
+
+        public override void AddUsesRemainingProperties(ObjectPropertyList list)
+        {
+			list.Add( 1060584, m_UsesRemaining.ToString() ); // uses remaining: ~1_val~
+		}
+
+		public CompassionPigment( Serial serial )
+			: base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 );
+
+			writer.Write( (int) m_Type );
+			writer.Write( (int) m_UsesRemaining );
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			m_Type = (CompassionPigmentType) reader.ReadInt();
+			m_UsesRemaining = reader.ReadInt();
+		}
+
+		private class DyeTarget : Target
+		{
+			private CompassionPigment m_Pigment;
+
+			public DyeTarget( CompassionPigment pigment )
+				: base( 8, false, TargetFlags.None )
+			{
+				m_Pigment = pigment;
+			}
+
+			protected override void OnTarget( Mobile from, object targeted )
+			{
+				Item item = targeted as Item;
+
+				if ( item == null )
+					return;
+
+				if ( !item.IsChildOf( from.Backpack ) )
+				{
+					from.SendLocalizedMessage( 1062334 ); // This item must be in your backpack to be used.
+				}
+                else if (item is MetalPigmentsOfTokuno || item is LesserPigmentsOfTokuno || item is PigmentsOfTokuno || item is CompassionPigment)
+                {
+					from.SendLocalizedMessage( 1042083 ); // You cannot dye that.
+				}
+				else if ( item.IsLockedDown )
+				{
+					from.SendLocalizedMessage( 1070932 ); // You may not dye artifacts and enhanced magic items which are locked down.
+				}
+				else if (BasePigmentsOfTokuno.IsValidItem(item))
+				{
+					item.Hue = m_Pigment.Hue;
+
+					m_Pigment.UsesRemaining--;
+
+					if ( m_Pigment.UsesRemaining <= 0 )
+						m_Pigment.Delete();
+				}
+				else
+				{
+					from.SendLocalizedMessage( 1070931 ); // You can only dye artifacts and enhanced magic items with this tub.
+				}
+			}
+		}
+	}
+}

Scripts/Services/CleanUpBritannia/Items/PresentationStone.cs

@@ -0,0 +1,36 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+    public class PresentationStone : Item
+    {
+        public override int LabelNumber { get { return 1154745; } } // Presentation Stone
+
+        [Constructable]
+        public PresentationStone()
+            : base(0x32F2)
+        {
+            Weight = 5.0;
+        }
+
+        public PresentationStone(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/Services/CleanUpBritannia/Items/PrimordialDecay.cs

@@ -0,0 +1,57 @@
+using System;
+
+namespace Server.Items
+{
+    public class PrimordialDecay : BaseInstrument
+    {
+        [Constructable]
+        public PrimordialDecay()
+        {
+            this.Hue = 1927;
+            this.Weight = 4;
+            this.Slayer = SlayerName.ElementalBan;
+
+            UsesRemaining = 450;
+        }
+
+        public PrimordialDecay(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1154723;
+            }
+        }// Primordial Decay
+        public override int InitMinUses
+        {
+            get
+            {
+                return 450;
+            }
+        }
+        public override int InitMaxUses
+        {
+            get
+            {
+                return 450;
+            }
+        }
+        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/Services/CleanUpBritannia/Items/RefinementAmalgamator.cs

@@ -0,0 +1,213 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Server.Targeting;
+
+namespace Server.Items
+{
+    public class RefinementAmalgamator : Item
+    {
+        public List<RefinementComponent> ToCombine { get; set; }
+        public RefinementComponent ToUpgrade { get; set; }
+
+        [Constructable]
+        public RefinementAmalgamator()
+            : base(0x9966)
+        {
+            Hue = 1152;
+            Weight = 1;
+        }
+
+        public RefinementAmalgamator(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1154340;
+            }
+        }// Refinement Amalgamator
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (!IsChildOf(from.Backpack))
+            {
+                // The item must be in your backpack to use it.
+                from.SendLocalizedMessage(1060640);
+            }
+            else
+            {
+                ToCombine = null;
+                ToUpgrade = null;
+
+                from.SendLocalizedMessage(1154351); // Target the refinement you wish to combine.
+                from.Target = new InternalTarget(from, this);
+            }
+        }
+
+        public void CheckCombine(Mobile m, RefinementComponent component)
+        {
+            if (ToUpgrade == null)
+            {
+                if (component.ModType != ModType.Invulnerability)
+                {
+                    ToCombine = new List<RefinementComponent>();
+                    ToUpgrade = component;
+
+                    m.SendLocalizedMessage(1154351); // Target the refinement you wish to combine.
+                    m.Target = new InternalTarget(m, this);
+                }
+                else
+                {
+                    m.SendLocalizedMessage(1154353); // You can't upgrade this refinement.
+                }
+            }
+            else 
+            {
+                if (ToUpgrade.RefinementType != component.RefinementType
+                            || ToUpgrade.CraftType != component.CraftType
+                            || ToUpgrade.SubCraftType != component.SubCraftType
+                            || ToUpgrade.ModType != component.ModType)
+                {
+                    m.SendLocalizedMessage(1154354); // This refinement does not match the type currently being combined.
+                }
+                else
+                {
+                    ToCombine.Add(component);
+                    ValidateList(m);
+
+                    if (ToCombine.Count >= GetCombineTotal(component.ModType) - 1) // -1 because we're counting ToUpgrade
+                    {
+                        foreach (var comp in ToCombine)
+                            comp.Delete();
+
+                        ToUpgrade.ModType++;
+
+                        m.SendLocalizedMessage(1154352); // You've completed the amalgamation and received an upgraded version of your refinement.
+                    }
+                    else
+                    {
+                        m.SendLocalizedMessage(1154360); // You place the refinement into the amalgamator.
+
+                        m.SendLocalizedMessage(1154351); // Target the refinement you wish to combine.
+                        m.Target = new InternalTarget(m, this);
+                    }
+                }
+            }
+        }
+
+        private void ValidateList(Mobile m)
+        {
+            if (ToCombine == null)
+                return;
+
+            var copy = new List<RefinementComponent>(ToCombine);
+
+            foreach (var comp in copy)
+            {
+                if (comp == null || comp.Deleted || !comp.IsChildOf(m.Backpack))
+                {
+                    ToCombine.Remove(comp);
+                }
+            }
+
+            ColUtility.Free(copy);
+        }
+
+        private int GetCombineTotal(ModType type)
+        {
+            switch (type)
+            {
+                default:
+                case ModType.Defense: return 2;
+                case ModType.Protection: return 3;
+                case ModType.Hardening: return 4;
+                case ModType.Fortification: return 5;
+                case ModType.Invulnerability: return -1;
+            }
+        }
+
+        private class InternalTarget : Target
+        {
+            private Mobile m_Mobile;
+            private RefinementAmalgamator m_Amalgamator;
+
+            public InternalTarget(Mobile m, RefinementAmalgamator amalgamator)
+                : base(-1, true, TargetFlags.None)
+            {
+                m_Mobile = m;
+                m_Amalgamator = amalgamator;
+            }
+
+            protected override void OnTarget(Mobile from, object targeted)
+            {
+                RefinementComponent item = targeted as RefinementComponent;
+
+                if (item == null)
+                {
+                    from.SendLocalizedMessage(1154457); // This is not a refinement.
+                }
+                else if (!item.IsChildOf(from.Backpack))
+                {
+                    from.SendLocalizedMessage(1060640); // The item must be in your backpack to use it.
+                }
+                else
+                {
+                    if (m_Amalgamator != null && !m_Amalgamator.Deleted)
+                    {
+                        m_Amalgamator.CheckCombine(from, item);
+                    }
+                    /*RefinementComponent comp = (RefinementComponent)targeted;
+
+                    if (ToCombine == null)
+                    {
+                        if (comp.ModType == ModType.Invulnerability)
+                        {
+                            from.SendLocalizedMessage(1154353); // You can't upgrade this refinement.
+                        }
+                        else
+                        {
+                            from.SendLocalizedMessage(1154351); // Target the refinement you wish to combine.
+                            from.Target = new InternalTarget(from, comp);
+                        }
+                    }
+                    else
+                    {
+                        if (m_First.RefinementType != comp.RefinementType
+                            || m_First.CraftType != comp.CraftType
+                            || m_First.SubCraftType != comp.SubCraftType
+                            || m_First.ModType != comp.ModType)
+                        {
+                            from.SendLocalizedMessage(1154354); // This refinement does not match the type currently being combined.
+                        }
+                        else
+                        {
+                            comp.Delete();
+                            m_First.ModType++;
+
+                            from.SendLocalizedMessage(1154352); // You've completed the amalgamation and received an upgraded version of your refinement.
+                        }
+                    }*/
+                }
+            }
+        }
+
+        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/Services/CleanUpBritannia/Items/SacrificeVirtueTile.cs

@@ -0,0 +1,117 @@
+using System;
+using Server;
+using Server.Gumps;
+
+namespace Server.Items
+{
+    public enum SacrificeTileType
+    {
+        North = 0,
+        West = 1,
+    }
+
+    public class SacrificeVirtueTileAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new SacrificeVirtueTileDeed(); } }
+
+        private SacrificeTileType m_SacrificeTileType;
+
+        private int offset;
+
+        [Constructable]
+        public SacrificeVirtueTileAddon(SacrificeTileType type)
+        {
+            m_SacrificeTileType = type;
+
+            offset = 0;
+
+            if (type == SacrificeTileType.North)
+            {
+                offset = 4;
+            }
+
+            AddComponent(new AddonComponent(5386 + offset), 0, 0, 0);
+            AddComponent(new AddonComponent(5387 + offset), 0, 1, 0);
+            AddComponent(new AddonComponent(5388 + offset), 1, 1, 0);
+            AddComponent(new AddonComponent(5389 + offset), 1, 0, 0);
+        }
+
+        public SacrificeVirtueTileAddon(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();
+        }
+    }
+
+    public class SacrificeVirtueTileDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new SacrificeVirtueTileAddon(m_SacrificeTileType); } }
+        public override int LabelNumber { get { return 1080482; } } // Sacrifice Virtue Tile Deed
+
+        private SacrificeTileType m_SacrificeTileType;
+
+        [Constructable]
+        public SacrificeVirtueTileDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public SacrificeVirtueTileDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)SacrificeTileType.North, 1080236);
+            list.Add((int)SacrificeTileType.West, 1080235);
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            m_SacrificeTileType = (SacrificeTileType)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+}

Scripts/Services/CleanUpBritannia/Items/SherryTheMouseStatue.cs

@@ -0,0 +1,78 @@
+using System;
+using Server.Mobiles;
+using Server.Network;
+
+namespace Server.Items
+{
+    public class SherryTheMouseStatue : Item
+    {
+        public override int LabelNumber { get { return 1080171; } } // Sherry the Mouse Statue
+        private Timer m_NewsTimer;
+
+        [Constructable]
+        public SherryTheMouseStatue()
+            : base(0x20D0)
+        {
+            LootType = LootType.Blessed;
+            Weight = 1.0;
+        }
+
+        public override bool HandlesOnSpeech { get { return true; } }
+
+        public override void OnSpeech(SpeechEventArgs e)
+        {
+            if (IsLockedDown && e.HasKeyword(0x30) && e.Mobile.Alive && e.Mobile.InLOS(Location) && e.Mobile.InRange(this, 12)) // *news*
+            {
+                TownCrierEntry tce = GlobalTownCrierEntryList.Instance.GetRandomEntry();
+
+                if (tce == null)
+                {
+                    PublicOverheadMessage(MessageType.Regular, 0x3B2, 1005643); // I have no news at this time.
+                }
+                else
+                {
+                    m_NewsTimer = Timer.DelayCall(TimeSpan.FromSeconds(1.0), TimeSpan.FromSeconds(3.0), new TimerStateCallback(ShoutNews_Callback), new object[] { tce, 0 });
+
+                    PublicOverheadMessage(MessageType.Regular, 0x3B2, 502978); // Some of the latest news!
+                }
+            }
+        }
+
+        private void ShoutNews_Callback(object state)
+        {
+            object[] states = (object[])state;
+            TownCrierEntry tce = (TownCrierEntry)states[0];
+            int index = (int)states[1];
+
+            if (index < 0 || index >= tce.Lines.Length)
+            {
+                if (m_NewsTimer != null)
+                    m_NewsTimer.Stop();
+
+                m_NewsTimer = null;
+            }
+            else
+            {
+                PublicOverheadMessage(MessageType.Regular, 0x3B2, false, tce.Lines[index]);
+                states[1] = index + 1;
+            }
+        }
+
+        public SherryTheMouseStatue(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/Services/CleanUpBritannia/Items/SnakeSkinBoots.cs

@@ -0,0 +1,37 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class SnakeSkinBoots : Boots
+    {
+        public override int LabelNumber { get { return 1080122; } } // Snake Skin Boots
+		public override bool IsArtifact { get { return true; } }
+
+        [Constructable]
+        public SnakeSkinBoots()
+        {
+            Hue = 0x7D9;
+            Resistances.Poison = 2;
+        }
+
+        public SnakeSkinBoots(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/CleanUpBritannia/Items/SoldiersMedal.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class SoldiersMedal : BaseTalisman
+    {
+		public override bool IsArtifact { get { return true; } }
+		
+        [Constructable]
+        public SoldiersMedal()
+            : base(0x2F5B)
+        {
+            this.Hue = 1902;
+            this.SkillBonuses.SetValues(0, SkillName.Tactics, 10.0);
+            this.Attributes.AttackChance = 5;
+            this.Attributes.RegenStam = 2;
+            this.Attributes.WeaponDamage = 20;
+        }
+
+        public SoldiersMedal(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1154726;
+            }
+        }// Soldier's Medal
+        public override bool ForceShowName
+        {
+            get
+            {
+                return true;
+            }
+        }
+        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/Services/CleanUpBritannia/Items/SophisticatedElvenTapestry.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x2D6F, 0x2D70)]
+    public class SophisticatedElvenTapestry : Item
+    {
+        [Constructable]
+        public SophisticatedElvenTapestry()
+            : base(0x2D70)
+        {
+            this.Weight = 1;
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1151222;
+            }
+        }// sophisticated elven tapestry
+
+        public SophisticatedElvenTapestry(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/Services/CleanUpBritannia/Items/SpiritualityVirtueTile.cs

@@ -0,0 +1,117 @@
+using System;
+using Server;
+using Server.Gumps;
+
+namespace Server.Items
+{
+    public enum SpiritualityTileType
+    {
+        North = 0,
+        West = 1,
+    }
+
+    public class SpiritualityVirtueTileAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new SpiritualityVirtueTileDeed(); } }
+
+        private SpiritualityTileType m_SpiritualityTileType;
+
+        private int offset;
+
+        [Constructable]
+        public SpiritualityVirtueTileAddon(SpiritualityTileType type)
+        {
+            m_SpiritualityTileType = type;
+
+            offset = 0;
+
+            if (type == SpiritualityTileType.North)
+            {
+                offset = 4;
+            }
+
+            AddComponent(new AddonComponent(5311 + offset), 0, 0, 0);
+            AddComponent(new AddonComponent(5312 + offset), 0, 1, 0);
+            AddComponent(new AddonComponent(5313 + offset), 1, 1, 0);
+            AddComponent(new AddonComponent(5314 + offset), 1, 0, 0);
+        }
+
+        public SpiritualityVirtueTileAddon(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();
+        }
+    }
+
+    public class SpiritualityVirtueTileDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new SpiritualityVirtueTileAddon(m_SpiritualityTileType); } }
+        public override int LabelNumber { get { return 1080484; } } // Spirituality Virtue Tile Deed
+
+        private SpiritualityTileType m_SpiritualityTileType;
+
+        [Constructable]
+        public SpiritualityVirtueTileDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public SpiritualityVirtueTileDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)SpiritualityTileType.North, 1080227);
+            list.Add((int)SpiritualityTileType.West, 1080226);
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            m_SpiritualityTileType = (SpiritualityTileType)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+}

Scripts/Services/CleanUpBritannia/Items/Steward.cs

@@ -0,0 +1,926 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Server.ContextMenus;
+using Server.Gumps;
+using Server.Items;
+using Server.Misc;
+using Server.Multis;
+using Server.Network;
+using Server.Prompts;
+using Server.Spells;
+using Server.Targeting;
+
+namespace Server.Mobiles
+{
+    public class Steward : BaseCreature
+    {
+        private Dictionary<Mobile, DateTime> _Table;
+
+        public override bool NoHouseRestrictions { get { return true; } }
+        public override bool ClickTitle { get { return false; } }
+        public override bool IsInvulnerable { get { return true; } }
+
+        private BaseHouse m_House;
+        public Mobile Owner { get; set; }
+        public string Keyword { get; set; }
+
+        public BaseHouse House
+        {
+            get { return m_House; }
+            set
+            {
+                if (m_House != null)
+                    m_House.PlayerVendors.Remove(this);
+
+                if (value != null)
+                    value.PlayerVendors.Add(this);
+
+                m_House = value;
+            }
+        }
+
+        [Constructable]
+        public Steward(Mobile owner, BaseHouse house)
+            : base(AIType.AI_Use_Default, FightMode.None, 1, 1, 0.2, 0.2)
+        {
+            InitStats(100, 100, 25);
+
+            Hits = HitsMax;
+            Blessed = true;
+            Frozen = true;
+
+            Owner = owner;
+            House = house;
+            Body = 0x190;
+            Race = Race.Human;
+            Name = "a Steward";
+            Hue = 1828;
+            Direction = Direction.South;
+
+            Keyword = "";
+            _Table = new Dictionary<Mobile, DateTime>();
+
+            Container pack = new StewardBackpack(Owner, this);
+            pack.Movable = false;
+            AddItem(pack);
+        }
+
+        public bool IsOwner(Mobile m)
+        {
+            if (m.AccessLevel >= AccessLevel.GameMaster)
+                return true;
+
+            return m == Owner;
+        }
+
+        public override bool CanBeDamaged()
+        {
+            return false;
+        }
+
+        public override bool CanBeRenamedBy(Mobile from)
+        {
+            return false;
+        }
+
+        public override bool AllowEquipFrom(Mobile from)
+        {
+            if (IsOwner(from))
+                return true;
+
+            return base.AllowEquipFrom(from);
+        }
+
+        public override bool CheckNonlocalLift(Mobile from, Item item)
+        {
+            if (IsOwner(from))
+                return true;
+
+            return base.CheckNonlocalLift(from, item);
+        }
+
+        public override bool CheckNonlocalDrop(Mobile from, Item item, Item target)
+        {
+            if (IsOwner(from))
+                return true;
+
+            return false;
+        }
+
+        public override void OnAosSingleClick(Mobile from)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            DisplayPaperdollTo(from);
+        }
+
+        public override bool OnDragDrop(Mobile from, Item dropped)
+        {
+            if (IsOwner(from) && Backpack != null)
+            {
+                return AddToBackpack(dropped);
+            }
+
+            return false;
+        }
+
+        public override bool HandlesOnSpeech(Mobile from)
+        {
+            return from is PlayerMobile;
+        }
+
+        public override void OnSpeech(SpeechEventArgs e)
+        {
+            PlayerMobile m = e.Mobile as PlayerMobile;
+
+            if (m == null || Keyword == "")
+                return;
+
+            if (e.Speech.Contains(Keyword))
+            {
+                if (Backpack == null || Backpack.Items.Count <= 0 || IsInCooldown(m))
+                {
+                    return;
+                }
+
+                if (Backpack.Items.Count > 0 && m.AddToBackpack(Backpack.Items[Utility.Random(Backpack.Items.Count)]))
+                {
+                    m.SendLocalizedMessage(1072223); // An item has been placed in your backpack.
+                    _Table[m] = DateTime.UtcNow + TimeSpan.FromHours(24);
+                }
+            }
+        }
+
+        public bool IsInCooldown(Mobile from)
+        {
+            if (_Table.ContainsKey(from))
+            {
+                if (_Table[from] < DateTime.UtcNow)
+                    _Table.Remove(from);
+            }
+
+            return _Table.ContainsKey(from);
+        }
+
+        public override void OnStatsQuery(Mobile from)
+        {
+            if (from.Map == Map && Utility.InUpdateRange(this, from) && from.CanSee(this))
+            {
+                from.Send(new MobileStatusCompact(false, this));
+
+                if (Map != null)
+                {
+                    ProcessDelta();
+
+                    Packet p = null;
+
+                    IPooledEnumerable eable = Map.GetClientsInRange(Location);
+
+                    foreach (NetState state in eable)
+                    {
+                        state.Mobile.ProcessDelta();
+
+                        if (p == null)
+                            p = Packet.Acquire(new UpdateStatueAnimation(this, 1, 4, 0));
+
+                        state.Send(p);
+                    }
+
+                    Packet.Release(p);
+
+                    eable.Free();
+                }
+            }
+        }
+
+        public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
+        {
+            base.GetContextMenuEntries(from, list);
+
+            if (IsOwner(Owner))
+            {
+                if (from.Alive && from.InRange(this, 4))
+                    list.Add(new CustomizeBodyEntry(from, this));
+
+                if (from.Alive && from.InRange(this, 2))
+                {
+                    list.Add(new RenameEntry(from, this));
+                    list.Add(new SetKeywordEntry(from, this));
+                    list.Add(new OpenBackpackEntry(from, this));
+
+                    if (from.Race == Race || (from.Race == Race.Elf && Race == Race.Human || from.Race == Race.Human && Race == Race.Elf))
+                    {
+                        list.Add(new SwitchClothesEntry(from, this));
+                    }
+
+                    list.Add(new RotateEntry(from, this));
+                    list.Add(new RedeedEntry(from, this));
+                }
+            }
+        }
+
+        private class RenameEntry : ContextMenuEntry
+        {
+            private Mobile _From;
+            private Mobile _Mannequin;
+
+            public RenameEntry(Mobile from, Mobile m)
+                : base(1155203, 2)
+            {
+                _From = from;
+                _Mannequin = m;
+            }
+
+            public override void OnClick()
+            {
+                _From.SendLocalizedMessage(1062494); // Enter a new name for your vendor (20 characters max):
+                _From.Prompt = new RenamePrompt(_Mannequin);
+            }
+        }
+
+        private class RenamePrompt : Prompt
+        {
+            public override int MessageCliloc { get { return 1062433; } }
+            private readonly Mobile _Mannequin;
+
+            public RenamePrompt(Mobile m)
+            {
+                _Mannequin = m;
+            }
+
+            public override void OnResponse(Mobile from, string text)
+            {
+                if (text.Length > 20)
+                {
+                    from.SendLocalizedMessage(501143); // That name is too long.
+                }
+                else
+                {
+                    _Mannequin.Name = text.Trim() == "" ? "Pat" : text;
+                    from.SendLocalizedMessage(1062496); // Your vendor has been renamed.
+                }
+            }
+        }
+
+        private class SetKeywordEntry : ContextMenuEntry
+        {
+            private Mobile _From;
+            private Mobile _Mannequin;
+
+            public SetKeywordEntry(Mobile from, Mobile m)
+                : base(1153254, 4)
+            {
+                _From = from;
+                _Mannequin = m;
+            }
+
+            public override void OnClick()
+            {
+                _From.SendLocalizedMessage(1153259); // Enter a new keyword for your npc (20 characters max):
+                _From.Prompt = new SetKeywordPrompt(_Mannequin);
+            }
+        }
+
+        private class SetKeywordPrompt : Prompt
+        {
+            private readonly Mobile _Mannequin;
+
+            public SetKeywordPrompt(Mobile m)
+            {
+                _Mannequin = m;
+            }
+
+            public override void OnResponse(Mobile from, string text)
+            {
+                if (text.Length > 20)
+                {
+                    from.SendLocalizedMessage(1153255); // That keyword is too long.
+                }
+                else
+                {
+                    if (_Mannequin is Steward)
+                    {
+                        ((Steward)_Mannequin).Keyword = text;
+                        from.SendLocalizedMessage(1153257); // The keyword has been set.
+                    }
+                }
+            }
+        }
+
+        private static bool ContainsDisallowedSpeech(string text)
+        {
+            foreach (var word in ProfanityProtection.Disallowed)
+            {
+                if (text.Contains(word))
+                    return true;
+            }
+            return false;
+        }
+
+        private class OpenBackpackEntry : ContextMenuEntry
+        {
+            private Mobile _From;
+            private Mobile _Mannequin;
+
+            public OpenBackpackEntry(Mobile from, Mobile m)
+                : base(3006145, 4)
+            {
+                _From = from;
+                _Mannequin = m;
+            }
+
+            public override void OnClick()
+            {
+                if (_Mannequin.Backpack != null)
+                    _Mannequin.Backpack.DisplayTo(_From);
+            }
+        }
+
+        private class CustomizeBodyEntry : ContextMenuEntry
+        {
+            private Mobile _From;
+            private Mobile _Mannequin;
+
+            public CustomizeBodyEntry(Mobile from, Mobile m)
+                : base(1151585, 4)
+            {
+                _From = from;
+                _Mannequin = m;
+            }
+
+            public override void OnClick()
+            {
+                _From.SendGump(new MannequinGump(_From, _Mannequin));
+            }
+        }
+
+        private class SwitchClothesEntry : ContextMenuEntry
+        {
+            private Mobile _From;
+            private Steward _Mannequin;
+
+            public SwitchClothesEntry(Mobile from, Steward m)
+                : base(1151606, 2)
+            {
+                _From = from;
+                _Mannequin = m;
+            }
+
+            public override void OnClick()
+            {
+                _Mannequin.SwitchClothes(_From, _Mannequin);
+            }
+        }
+
+        public static bool IsEquipped(Item item)
+        {
+            return item != null && item.Parent is Mobile && ((Mobile)item.Parent).FindItemOnLayer(item.Layer) == item &&
+                   item.Layer != Layer.Mount && item.Layer != Layer.Bank &&
+                   item.Layer != Layer.Invalid && item.Layer != Layer.Backpack && !(item is Backpack);
+        }
+
+        public void SwitchClothes(Mobile from, Mobile m)
+        {
+            List<Item> MobileItems = from.Items.Where(x => IsEquipped(x)).ToList();
+            List<Item> MannequinItems = m.Items.Where(x => IsEquipped(x)).ToList();
+
+            MannequinItems.ForEach(x => m.RemoveItem(x));
+            MobileItems.ForEach(x => from.RemoveItem(x));
+
+            List<Item> ExceptItems = new List<Item>();
+
+            MannequinItems.ForEach(x =>
+            {
+                if (x.CanEquip(from))
+                {
+                    from.EquipItem(x);
+                }
+                else
+                {
+                    ExceptItems.Add(x);
+                }
+            });
+
+            MobileItems.ForEach(x =>
+            {
+                if (x.CanEquip(m))
+                {
+                    m.EquipItem(x);
+                }
+                else
+                {
+                    ExceptItems.Add(x);
+                }
+            });
+
+            if (ExceptItems.Count > 0)
+            {
+                ExceptItems.ForEach(x => from.AddToBackpack(x));
+                from.SendLocalizedMessage(1151641, ExceptItems.Count.ToString(), 0x22); // ~1_COUNT~ items could not be swapped between you and the mannequin. These items are now in your backpack, or on the floor at your feet if your backpack is too full to hold them.
+            }
+
+            from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1151607); // You quickly swap clothes with the mannequin.
+        }
+
+        private class RotateEntry : ContextMenuEntry
+        {
+            private Mobile _From;
+            private Mobile _Mannequin;
+
+            public RotateEntry(Mobile from, Mobile m)
+                : base(1151586, 2)
+            {
+                _From = from;
+                _Mannequin = m;
+            }
+
+            public override void OnClick()
+            {
+                int direction = (int)_Mannequin.Direction;
+                direction++;
+
+                if (direction > 0x7)
+                    direction = 0x0;
+
+                _Mannequin.Direction = (Direction)direction;
+
+                _From.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1151587); // You rotate the mannequin a little bit.
+            }
+        }
+
+        private class RedeedEntry : ContextMenuEntry
+        {
+            private Mobile _From;
+            private Mobile _Mannequin;
+
+            public RedeedEntry(Mobile from, Mobile m)
+                : base(1151601, 2)
+            {
+                _From = from;
+                _Mannequin = m;
+            }
+
+            public override void OnClick()
+            {
+                if (_Mannequin.Backpack != null && _Mannequin.Backpack.Items.Any())
+                {
+                    _From.SendLocalizedMessage(1153315); // You must empty the mannequin's backpack before re-deeding.
+                    return;
+                }
+
+                List<Item> mannequinItems = _Mannequin.Items.Where(x => IsEquipped(x)).ToList();
+                mannequinItems.ForEach(x => _From.AddToBackpack(x));
+
+                _Mannequin.Delete();
+
+                _From.AddToBackpack(new StewardDeed());
+            }
+        }
+
+        public override void OnAfterDelete()
+        {
+            base.OnAfterDelete();
+
+            House = null;
+        }
+
+        public Steward(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)1); // version
+
+            writer.Write((Item)House);
+            writer.Write(Owner);
+            writer.Write(Keyword);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            _Table = new Dictionary<Mobile, DateTime>();
+
+            switch (version)
+            {
+                case 1:
+                    {
+                        House = (BaseHouse)reader.ReadItem();
+                        goto case 0;
+                    }
+                case 0:
+                    {
+                        Timer.DelayCall(TimeSpan.FromSeconds(15), () => { House = BaseHouse.FindHouseAt(this); });
+
+                        Owner = reader.ReadMobile();
+                        Keyword = reader.ReadString();
+
+                        break;
+                    }
+            }
+        }
+    }
+
+    public class StewardBackpack : Backpack
+    {
+        private Mobile _Owner;
+        private Mobile _Mannequin;
+
+        public StewardBackpack(Mobile from, Mobile m)
+        {
+            _Owner = from;
+            _Mannequin = m;
+
+            Layer = Layer.Backpack;
+        }
+
+        public override int DefaultMaxWeight { get { return 400; } }
+
+        public StewardBackpack(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public virtual bool IsOwner(Mobile m)
+        {
+            if (m.AccessLevel >= AccessLevel.GameMaster)
+                return true;
+
+            return m == _Owner;
+        }
+
+        public override bool CheckItemUse(Mobile from, Item item)
+        {
+            return false;
+        }
+
+        public override bool OnDragDrop(Mobile from, Item dropped)
+        {
+            return base.OnDragDrop(from, dropped);
+        }
+
+        public override bool IsAccessibleTo(Mobile m)
+        {
+            return IsOwner(m);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)1); // version
+
+            writer.Write(_Mannequin);
+            writer.Write(_Owner);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            switch (version)
+            {
+                case 1:
+                    {
+                        _Mannequin = reader.ReadMobile();
+                        goto case 0;
+                    }
+                case 0:
+                    {
+                        _Owner = reader.ReadMobile();
+
+                        break;
+                    }
+            }
+        }
+    }
+
+    public class MannequinGump : Gump
+    {
+        private Mobile _From;
+        private Mobile _Mannequin;
+
+        public MannequinGump(Mobile from, Mobile m)
+            : base(50, 50)
+        {
+            _From = from;
+            _Mannequin = m;
+
+            AddPage(0);
+
+            AddBackground(0, 0, 300, 130, 0x13BE);
+            AddImageTiled(10, 10, 280, 20, 0xA40);
+            AddImageTiled(10, 40, 280, 80, 0xA40);
+            AddAlphaRegion(10, 10, 280, 110);
+            AddHtmlLocalized(10, 12, 280, 18, 1151582, 0x7FFF, false, false); // <center>CUSTOMIZE BODY</center>
+
+            AddHtmlLocalized(45, 52, 180, 18, 1072255, _Mannequin.Race == Race.Human ? 0x1CFF : 0x7FFF, false, false); // Human
+            AddButton(10, 50, 0xFA5, 0xFA7, 1, GumpButtonType.Reply, 0);
+
+            AddHtmlLocalized(45, 72, 180, 18, 1072256, _Mannequin.Race == Race.Elf ? 0x1CFF : 0x7FFF, false, false); // Elf
+            AddButton(10, 70, 0xFA5, 0xFA7, 2, GumpButtonType.Reply, 0);
+
+            AddHtmlLocalized(45, 92, 180, 18, 1029613, _Mannequin.Race == Race.Gargoyle ? 0x1CFF : 0x7FFF, false, false); // Gargoyle 
+            AddButton(10, 90, 0xFA5, 0xFA7, 3, GumpButtonType.Reply, 0);
+
+            AddHtmlLocalized(205, 52, 180, 18, 1015327, _Mannequin.Female ? 0x7FFF : 0x1CFF, false, false); // Male
+            AddButton(170, 50, 0xFA6, 0xFA6, 4, GumpButtonType.Reply, 0);
+
+            AddHtmlLocalized(205, 72, 180, 18, 1015328, _Mannequin.Female ? 0x1CFF : 0x7FFF, false, false); // Female
+            AddButton(170, 70, 0xFA5, 0xFA7, 5, GumpButtonType.Reply, 0);
+        }
+
+        public void ValidateItems(Mobile from, Mobile m)
+        {
+            List<Item> MannequinItems = m.Items.Where(x => Steward.IsEquipped(x)).ToList();
+            MannequinItems.ForEach(x => _Mannequin.RemoveItem(x));
+
+            List<Item> ExceptItems = new List<Item>();
+
+            MannequinItems.ForEach(x =>
+            {
+                if (x.CanEquip(m))
+                {
+                    m.EquipItem(x);
+                }
+                else
+                {
+                    ExceptItems.Add(x);
+                }
+            });
+
+            if (ExceptItems.Count > 0)
+            {
+                ExceptItems.ForEach(x => from.AddToBackpack(x));
+                from.SendLocalizedMessage(1151641, ExceptItems.Count.ToString(), 0x22); // ~1_COUNT~ items could not be swapped between you and the mannequin. These items are now in your backpack, or on the floor at your feet if your backpack is too full to hold them.
+            }
+        }
+
+        public override void OnResponse(NetState state, RelayInfo info)
+        {
+            if (_Mannequin == null)
+                return;
+
+            Mobile from = state.Mobile;
+
+            switch (info.ButtonID)
+            {
+                case 1: // Human
+                    {
+                        if (_Mannequin.Female)
+                        {
+                            _Mannequin.Body = 0x190;
+                        }
+                        else
+                        {
+                            _Mannequin.Body = 0x191;
+                        }
+
+                        _Mannequin.Race = Race.Human;
+
+                        ValidateItems(from, _Mannequin);
+
+                        break;
+                    }
+                case 2: // Elf
+                    {
+                        if (_Mannequin.Female)
+                        {
+                            _Mannequin.Body = 0x25d;
+                        }
+                        else
+                        {
+                            _Mannequin.Body = 0x25e;
+                        }
+
+                        _Mannequin.Race = Race.Elf;
+
+                        ValidateItems(from, _Mannequin);
+
+                        break;
+                    }
+                case 3: // Gargoyle
+                    {
+                        if (_Mannequin.Female)
+                        {
+                            _Mannequin.Body = 0x29a;
+                        }
+                        else
+                        {
+                            _Mannequin.Body = 0x29b;
+                        }
+
+                        _Mannequin.Race = Race.Gargoyle;
+
+                        ValidateItems(from, _Mannequin);
+
+                        break;
+                    }
+                case 4: // Male
+                    {
+                        if (_Mannequin.Race == Race.Human)
+                        {
+                            _Mannequin.Body = 0x190;
+                        }
+                        else if (_Mannequin.Race == Race.Elf)
+                        {
+                            _Mannequin.Body = 0x25d;
+                        }
+                        else if (_Mannequin.Race == Race.Gargoyle)
+                        {
+                            _Mannequin.Body = 0x29a;
+                        }
+
+                        _Mannequin.Female = false;
+
+                        ValidateItems(from, _Mannequin);
+
+                        break;
+                    }
+                case 5: // Female
+                    {
+                        if (_Mannequin.Race == Race.Human)
+                        {
+                            _Mannequin.Body = 0x191;
+                        }
+                        else if (_Mannequin.Race == Race.Elf)
+                        {
+                            _Mannequin.Body = 0x25e;
+                        }
+                        else if (_Mannequin.Race == Race.Gargoyle)
+                        {
+                            _Mannequin.Body = 0x29b;
+                        }
+
+                        _Mannequin.Female = true;
+
+                        ValidateItems(from, _Mannequin);
+
+                        break;
+                    }
+            }
+        }
+    }
+
+    [Flipable(0x14F0, 0x14EF)]
+    public class StewardDeed : Item
+    {
+        public override int LabelNumber { get { return 1153344; } } // Steward Deed
+
+        [Constructable]
+        public StewardDeed()
+            : base(0x14F0)
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public StewardDeed(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                BaseHouse house = BaseHouse.FindHouseAt(from);
+
+                if (house != null)
+                {
+                    if (house.Owner == from || house.IsCoOwner(from))
+                    {
+                        if (house.Public)
+                        {
+                            from.SendLocalizedMessage(1151657); // Where do you wish to place this?
+                            from.Target = new PlaceTarget(this);
+                        }
+                        else
+                        {
+                            from.SendLocalizedMessage(1153304); // You cannot place this vendor, steward or barkeep. Make sure the house is public and has sufficient storage available.
+                        }
+                    }
+                    else
+                    {
+                        from.SendLocalizedMessage(502096); // You must own the house to do this.
+                    }
+                }
+                else
+                {
+                    from.SendLocalizedMessage(502092); // You must be in your house to do this.
+                }
+            }
+            else
+            {
+                from.SendLocalizedMessage(1042001); // That must be in your pack for you to use it.
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class PlaceTarget : Target
+    {
+        private Item _Deed;
+
+        public PlaceTarget(Item deed)
+            : base(-1, true, TargetFlags.None)
+        {
+            _Deed = deed;
+        }
+
+        public static AddonFitResult CouldFit(Point3D p, Map map, Mobile from, ref BaseHouse house)
+        {
+            if (!map.CanFit(p.X, p.Y, p.Z, 20, true, true, true))
+                return AddonFitResult.Blocked;
+            else if (!BaseAddon.CheckHouse(from, p, map, 20, ref house))
+                return AddonFitResult.NotInHouse;
+            else
+                return CheckDoors(p, 20, house);
+        }
+
+        public static AddonFitResult CheckDoors(Point3D p, int height, BaseHouse house)
+        {
+            List<Item> doors = house.Doors;
+
+            for (int i = 0; i < doors.Count; i++)
+            {
+                BaseDoor door = doors[i] as BaseDoor;
+
+                Point3D doorLoc = door.GetWorldLocation();
+                int doorHeight = door.ItemData.CalcHeight;
+
+                if (Utility.InRange(doorLoc, p, 1) && (p.Z == doorLoc.Z || ((p.Z + height) > doorLoc.Z && (doorLoc.Z + doorHeight) > p.Z)))
+                    return AddonFitResult.DoorTooClose;
+            }
+
+            return AddonFitResult.Valid;
+        }
+
+        protected override void OnTarget(Mobile from, object targeted)
+        {
+            IPoint3D p = targeted as IPoint3D;
+            Map map = from.Map;
+
+            if (p == null || map == null || _Deed == null || _Deed.Deleted)
+                return;
+
+            if (_Deed.IsChildOf(from.Backpack))
+            {
+                SpellHelper.GetSurfaceTop(ref p);
+                BaseHouse house = null;
+                Point3D loc = new Point3D(p);
+
+                if (targeted is Item && !((Item)targeted).IsLockedDown && !((Item)targeted).IsSecure && !(targeted is AddonComponent))
+                {
+                    from.SendLocalizedMessage(1151655); // The mannequin cannot fit there.
+                    return;
+                }
+
+                AddonFitResult result = CouldFit(loc, map, from, ref house);
+
+                if (result == AddonFitResult.Valid)
+                {
+                    Mobile mannequin;
+
+                    if (_Deed is StewardDeed)
+                    {
+                        mannequin = new Steward(from, house);
+                    }
+                    else
+                    {
+                        mannequin = new Mannequin(from);
+                    }
+
+                    mannequin.MoveToWorld(loc, map);
+                    _Deed.Delete();
+                }
+                else
+                {
+                    from.SendLocalizedMessage(1151655); // The mannequin cannot fit there.
+                }
+            }
+            else
+            {
+                from.SendLocalizedMessage(1042001); // That must be in your pack for you to use it.
+            }
+        }
+    }
+}

Scripts/Services/CleanUpBritannia/Items/TableLamp.cs

@@ -0,0 +1,49 @@
+using System;
+
+namespace Server.Items
+{
+    public class TableLamp : Item
+    {
+        [Constructable]
+        public TableLamp()
+            : base(0x49C2)
+        {
+            this.Weight = 1;
+        }
+
+        public TableLamp(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1151220;
+            }
+        }// table lamp
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (this.ItemID == 0x49C2)
+                this.ItemID = 0x49C1;
+            else if (this.ItemID == 0x49C1)
+                this.ItemID = 0x49C2;
+        }
+
+        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/Services/CleanUpBritannia/Items/ValorVirtueTile.cs

@@ -0,0 +1,117 @@
+using System;
+using Server;
+using Server.Gumps;
+
+namespace Server.Items
+{
+    public enum ValorTileType
+    {
+        North = 0,
+        West = 1,
+    }
+
+    public class ValorVirtueTileAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new ValorVirtueTileDeed(); } }
+
+        private ValorTileType m_ValorTileType;
+
+        private int offset;
+
+        [Constructable]
+        public ValorVirtueTileAddon(ValorTileType type)
+        {
+            m_ValorTileType = type;
+
+            offset = 0;
+
+            if (type == ValorTileType.North)
+            {
+                offset = 4;
+            }
+
+            AddComponent(new AddonComponent(5303 + offset), 0, 0, 0);
+            AddComponent(new AddonComponent(5304 + offset), 0, 1, 0);
+            AddComponent(new AddonComponent(5305 + offset), 1, 1, 0);
+            AddComponent(new AddonComponent(5306 + offset), 1, 0, 0);
+        }
+
+        public ValorVirtueTileAddon(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();
+        }
+    }
+
+    public class ValorVirtueTileDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new ValorVirtueTileAddon(m_ValorTileType); } }
+        public override int LabelNumber { get { return 1080486; } } // Valor Virtue Tile Deed
+
+        private ValorTileType m_ValorTileType;
+
+        [Constructable]
+        public ValorVirtueTileDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public ValorVirtueTileDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)ValorTileType.North, 1080224);
+            list.Add((int)ValorTileType.West, 1080223);
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            m_ValorTileType = (ValorTileType)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+}

Scripts/Services/CleanUpBritannia/Items/VollemHeldInCrystal.cs

@@ -0,0 +1,73 @@
+using System;
+using Server.Gumps;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class VollemHeldInCrystal : BaseImprisonedMobile
+    {
+        public override int LabelNumber { get { return 1113629; } } // A Vollem Held in Crystal
+
+        [Constructable]
+        public VollemHeldInCrystal()
+            : base(0x1f19)
+        {
+            Hue = 1154;
+            LootType = LootType.Blessed;
+            Weight = 1;
+        }
+
+        public override BaseCreature Summon { get { return new VollemHeld(); } }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+                from.SendGump(new ConfirmBreakCrystalGump(this));
+            else
+                from.SendLocalizedMessage(1010095); // This must be on your person to use.
+        }
+
+        public VollemHeldInCrystal(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();
+        }
+    }
+
+    public class VollemHeld : Vollem
+    {
+        [Constructable]
+        public VollemHeld()
+            : base()
+        {
+        }
+
+        public VollemHeld(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/Services/CleanUpBritannia/Items/WizardsCurio.cs

@@ -0,0 +1,54 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{ 
+    public class WizardsCurio : BaseTalisman
+    {
+		public override bool IsArtifact { get { return true; } }
+		
+        [Constructable]
+        public WizardsCurio()
+            : base(0x2F58)
+        {
+            this.Hue = 1912;
+            this.SkillBonuses.SetValues(0, SkillName.EvalInt, 10.0);
+            this.Attributes.RegenMana = 1;
+            this.Attributes.LowerRegCost = 10;
+            this.Attributes.SpellDamage = 5;
+        }
+
+        public WizardsCurio(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1154729;
+            }
+        }// Wizard's Curio
+        public override bool ForceShowName
+        {
+            get
+            {
+                return true;
+            }
+        }
+        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/Services/CleanUpBritannia/Items/YuccaTree.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace Server.Items
+{
+    public class YuccaTree : Item
+    {
+        [Constructable]
+        public YuccaTree()
+            : base(0x0D37)
+        {
+            this.Weight = 10;
+        }
+
+        public YuccaTree(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1023383;
+            }
+        }// yucca
+        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();
+        }
+    }
+}