Overwrite

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

Server/Items/BaseMulti.cs

@@ -0,0 +1,177 @@
+#region References
+using Server.Network;
+using System;
+#endregion
+
+namespace Server.Items
+{
+	public class BaseMulti : Item
+	{
+		[Constructable]
+		public BaseMulti(int itemID)
+			: base(itemID)
+		{
+			Movable = false;
+		}
+
+		public BaseMulti(Serial serial)
+			: base(serial)
+		{ }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public override int ItemID
+		{
+			get { return base.ItemID; }
+			set
+			{
+				if (base.ItemID != value)
+				{
+					Map facet = (Parent == null ? Map : null);
+
+					if (facet != null)
+					{
+						facet.OnLeave(this);
+					}
+
+					base.ItemID = value;
+
+					if (facet != null)
+					{
+						facet.OnEnter(this);
+					}
+				}
+			}
+		}
+
+		[Obsolete("Replace with calls to OnLeave and OnEnter surrounding component invalidation.", true)]
+		public virtual void RefreshComponents()
+		{
+			if (Parent == null)
+			{
+				Map facet = Map;
+
+				if (facet != null)
+				{
+					facet.OnLeave(this);
+					facet.OnEnter(this);
+				}
+			}
+		}
+
+        public override int LabelNumber
+		{
+			get
+			{
+				MultiComponentList mcl = Components;
+
+				if (mcl.List.Length > 0)
+				{
+					int id = mcl.List[0].m_ItemID;
+
+					if (id < 0x4000)
+					{
+						return 1020000 + id;
+					}
+					else
+					{
+						return 1078872 + id;
+					}
+				}
+
+				return base.LabelNumber;
+			}
+		}
+
+		public virtual bool AllowsRelativeDrop { get { return false; } }
+	
+		public override int GetUpdateRange(Mobile m)
+		{
+            int min = m.NetState != null ? m.NetState.UpdateRange : Core.GlobalUpdateRange;
+            int max = Core.GlobalRadarRange - 1;
+
+            int w = Components.Width;
+            int h = Components.Height - 1;
+            int v = min + ((w > h ? w : h) / 2);
+
+            if (v > max)
+                v = max;
+            else if (v < min)
+                v = min;
+
+            return v;
+		}
+
+		public virtual MultiComponentList Components { get { return MultiData.GetComponents(ItemID); } }
+
+		public virtual bool Contains(Point2D p)
+		{
+			return Contains(p.m_X, p.m_Y);
+		}
+
+		public virtual bool Contains(Point3D p)
+		{
+			return Contains(p.m_X, p.m_Y);
+		}
+
+		public virtual bool Contains(IPoint3D p)
+		{
+			return Contains(p.X, p.Y);
+		}
+
+		public virtual bool Contains(int x, int y)
+		{
+			MultiComponentList mcl = Components;
+
+			x -= X + mcl.Min.m_X;
+			y -= Y + mcl.Min.m_Y;
+
+			return x >= 0 && x < mcl.Width && y >= 0 && y < mcl.Height && mcl.Tiles[x][y].Length > 0;
+		}
+
+		public bool Contains(Mobile m)
+		{
+			if (m.Map == Map)
+			{
+				return Contains(m.X, m.Y);
+			}
+			else
+			{
+				return false;
+			}
+		}
+
+		public bool Contains(Item item)
+		{
+			if (item.Map == Map)
+			{
+				return Contains(item.X, item.Y);
+			}
+			else
+			{
+				return false;
+			}
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.Write(1); // version
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			int version = reader.ReadInt();
+
+			if (version == 0)
+			{
+				if (ItemID >= 0x4000)
+				{
+					ItemID -= 0x4000;
+				}
+			}
+		}
+	}
+}

Server/Items/Containers.cs

@@ -0,0 +1,163 @@
+#region References
+using System;
+
+using Server.Accounting;
+using Server.Network;
+#endregion
+
+namespace Server.Items
+{
+	public class BankBox : Container
+	{
+		private static readonly Type _GoldType = ScriptCompiler.FindTypeByFullName("Server.Items.Gold");
+		private static readonly Type _CheckType = ScriptCompiler.FindTypeByFullName("Server.Items.BankCheck");
+
+		public static bool SendDeleteOnClose { get; set; }
+
+		private Mobile m_Owner;
+		private bool m_Open;
+
+		public override int DefaultMaxWeight { get { return 0; } }
+
+		public override bool IsVirtualItem { get { return true; } }
+
+		public Mobile Owner { get { return m_Owner; } }
+
+		public bool Opened { get { return m_Open; } }
+
+		public BankBox(Mobile owner)
+			: base(0xE7C)
+		{
+			m_Owner = owner;
+
+			Movable = false;
+			Layer = Layer.Bank;
+		}
+
+		public BankBox(Serial serial)
+			: base(serial)
+		{ }
+		
+		public void Open()
+		{
+			if (m_Owner != null && m_Owner.NetState != null)
+			{
+			m_Open = true;
+
+				m_Owner.PrivateOverheadMessage(
+					MessageType.Regular,
+					0x3B2,
+					true,
+					String.Format("Bank container has {0} items, {1} stones", TotalItems, TotalWeight),
+					m_Owner.NetState);
+
+				m_Owner.Send(new EquipUpdate(this));
+
+				DisplayTo(m_Owner);
+			}
+		}
+
+		public void Close()
+		{
+			m_Open = false;
+
+			if (m_Owner != null && SendDeleteOnClose)
+			{
+				m_Owner.Send(RemovePacket);
+			}
+		}
+
+		public override void OnSingleClick(Mobile from)
+		{ }
+
+		public override void OnDoubleClick(Mobile from)
+		{ }
+
+		public override DeathMoveResult OnParentDeath(Mobile parent)
+		{
+			return DeathMoveResult.RemainEquiped;
+		}
+
+		public override bool IsAccessibleTo(Mobile check)
+		{
+			if ((check == m_Owner && m_Open) || check.AccessLevel >= AccessLevel.GameMaster)
+			{
+				return base.IsAccessibleTo(check);
+			}
+
+			return false;
+		}
+
+		public override bool OnDragDrop(Mobile from, Item dropped)
+		{
+			if ((from == m_Owner && m_Open) || from.AccessLevel >= AccessLevel.GameMaster)
+			{
+				return base.OnDragDrop(from, dropped);
+			}
+
+			return false;
+		}
+
+		public override bool OnDragDropInto(Mobile from, Item item, Point3D p)
+		{
+			if ((from == m_Owner && m_Open) || from.AccessLevel >= AccessLevel.GameMaster)
+			{
+				return base.OnDragDropInto(from, item, p);
+			}
+
+			return false;
+		}
+
+		public override int GetTotal(TotalType type)
+		{
+			if (AccountGold.Enabled && Owner != null && Owner.Account != null && type == TotalType.Gold)
+			{
+				return Owner.Account.TotalGold;
+			}
+
+			return base.GetTotal(type);
+		}
+
+		public override bool CheckHold(Mobile m, Item item, bool message, bool checkItems, int plusItems, int plusWeight)
+		{
+			Type type = item.GetType();
+
+			if (AccountGold.Enabled && Owner != null && Owner.Account != null && (type.IsAssignableFrom(_GoldType) || type.IsAssignableFrom(_CheckType)))
+			{
+				return true;
+			}
+
+			return base.CheckHold(m, item, message, checkItems, plusItems, plusWeight);
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.Write(0); // version
+
+			writer.Write(m_Owner);
+			writer.Write(m_Open);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.ReadInt();
+
+			m_Owner = reader.ReadMobile();
+			m_Open = reader.ReadBool();
+
+			if (ItemID == 0xE41)
+			{
+				ItemID = 0xE7C;
+			}
+
+			if (m_Owner == null)
+			{
+				Delete();
+			}
+		}
+	}
+}

Server/Items/SecureTradeContainer.cs

@@ -0,0 +1,129 @@
+#region References
+using Server.Accounting;
+using Server.Network;
+#endregion
+
+namespace Server.Items
+{
+	public class SecureTradeContainer : Container
+	{
+		private readonly SecureTrade m_Trade;
+
+		public SecureTrade Trade { get { return m_Trade; } }
+
+		public SecureTradeContainer(SecureTrade trade)
+			: base(0x1E5E)
+		{
+			m_Trade = trade;
+			Movable = false;
+
+            Layer = Layer.SecureTrade;
+		}
+
+		public SecureTradeContainer(Serial serial)
+			: base(serial)
+		{ }
+
+		public override bool CheckHold(Mobile m, Item item, bool message, bool checkItems, int plusItems, int plusWeight)
+		{
+			if (item == Trade.From.VirtualCheck || item == Trade.To.VirtualCheck)
+			{
+				return true;
+			}
+
+			var to = Trade.From.Container != this ? Trade.From.Mobile : Trade.To.Mobile;
+
+			return m.CheckTrade(to, item, this, message, checkItems, plusItems, plusWeight);
+		}
+
+		public override bool CheckLift(Mobile from, Item item, ref LRReason reject)
+		{
+			reject = LRReason.CannotLift;
+			return false;
+		}
+
+		public override bool IsAccessibleTo(Mobile check)
+		{
+			if (!IsChildOf(check) || m_Trade == null || !m_Trade.Valid)
+			{
+				return false;
+			}
+
+			return base.IsAccessibleTo(check);
+		}
+
+		public override void OnItemAdded(Item item)
+		{
+			if (!(item is VirtualCheck))
+			{
+				ClearChecks();
+			}
+		}
+
+		public override void OnItemRemoved(Item item)
+		{
+			if (!(item is VirtualCheck))
+			{
+				ClearChecks();
+			}
+		}
+
+		public override void OnSubItemAdded(Item item)
+		{
+			if (!(item is VirtualCheck))
+			{
+				ClearChecks();
+			}
+		}
+
+		public override void OnSubItemRemoved(Item item)
+		{
+			if (!(item is VirtualCheck))
+			{
+				ClearChecks();
+			}
+		}
+
+		public void ClearChecks()
+		{
+			if (m_Trade != null)
+			{
+				if (m_Trade.From != null && !m_Trade.From.IsDisposed)
+				{
+					m_Trade.From.Accepted = false;
+				}
+
+				if (m_Trade.To != null && !m_Trade.To.IsDisposed)
+				{
+					m_Trade.To.Accepted = false;
+				}
+
+				m_Trade.Update();
+			}
+		}
+
+		public override bool IsChildVisibleTo(Mobile m, Item child)
+		{
+			if (child is VirtualCheck)
+			{
+				return AccountGold.Enabled && (m.NetState == null || !m.NetState.NewSecureTrading);
+			}
+
+			return base.IsChildVisibleTo(m, child);
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.Write(0);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.ReadInt();
+		}
+	}
+}

Server/Items/VirtualCheck.cs

@@ -0,0 +1,389 @@
+#region References
+using System;
+using System.Drawing;
+
+using Server.Accounting;
+using Server.Gumps;
+using Server.Network;
+#endregion
+
+namespace Server
+{
+	public sealed class VirtualCheck : Item
+	{
+		public static bool UseEditGump = false;
+
+		public override bool IsVirtualItem { get { return true; } }
+
+		public override bool DisplayWeight { get { return false; } }
+		public override bool DisplayLootType { get { return false; } }
+
+		public override double DefaultWeight { get { return 0; } }
+
+		public override string DefaultName { get { return "Offer Of Currency"; } }
+
+		public EditGump Editor { get; private set; }
+
+		private int _Plat;
+
+		[CommandProperty(AccessLevel.Administrator)]
+		public int Plat
+		{
+			get { return _Plat; }
+			set
+			{
+				_Plat = value;
+				InvalidateProperties();
+			}
+		}
+
+		private int _Gold;
+
+		[CommandProperty(AccessLevel.Administrator)]
+		public int Gold
+		{
+			get { return _Gold; }
+			set
+			{
+				_Gold = value;
+				InvalidateProperties();
+			}
+		}
+
+		public VirtualCheck()
+			: this(0, 0)
+		{ }
+
+		public VirtualCheck(int plat, int gold)
+			: base(0x14F0)
+		{
+			Plat = plat;
+			Gold = gold;
+
+			Movable = false;
+		}
+
+		public VirtualCheck(Serial serial)
+			: base(serial)
+		{ }
+
+		public override bool IsAccessibleTo(Mobile check)
+		{
+			var c = GetSecureTradeCont();
+
+			if (check == null || c == null)
+			{
+				return base.IsAccessibleTo(check);
+			}
+
+			return c.RootParent == check && IsChildOf(c);
+		}
+
+		public override void OnDoubleClickSecureTrade(Mobile from)
+		{
+			if (UseEditGump && IsAccessibleTo(from))
+			{
+				if (Editor == null || Editor.Check == null || Editor.Check.Deleted)
+				{
+					Editor = new EditGump(from, this);
+					Editor.Send();
+				}
+				else
+				{
+					Editor.Refresh(true);
+				}
+			}
+			else
+			{
+				if (Editor != null)
+				{
+					Editor.Close();
+					Editor = null;
+				}
+
+				base.OnDoubleClickSecureTrade(from);
+			}
+		}
+
+		public override void OnSingleClick(Mobile from)
+		{
+			LabelTo(from, "Offer: {0:#,0} platinum, {1:#,0} gold", Plat, Gold);
+		}
+
+		public override void GetProperties(ObjectPropertyList list)
+		{
+			base.GetProperties(list);
+
+			list.Add(1060738, String.Format("{0:#,0} platinum, {1:#,0} gold", Plat, Gold)); // value: ~1_val~
+		}
+
+		public void UpdateTrade(Mobile user)
+		{
+			var c = GetSecureTradeCont();
+
+			if (c == null || c.Trade == null)
+			{
+				return;
+			}
+
+			if (user == c.Trade.From.Mobile)
+			{
+				c.Trade.UpdateFromCurrency();
+			}
+			else if (user == c.Trade.To.Mobile)
+			{
+				c.Trade.UpdateToCurrency();
+			}
+
+			c.ClearChecks();
+		}
+
+		public override void OnAfterDelete()
+		{
+			base.OnAfterDelete();
+
+			if (Editor != null)
+			{
+				Editor.Close();
+				Editor = null;
+			}
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{ }
+
+		public override void Deserialize(GenericReader reader)
+		{
+			Delete();
+		}
+
+		public class EditGump : Gump
+		{
+			public enum Buttons
+			{
+				Close,
+				Clear,
+				Accept,
+				AllPlat,
+				AllGold
+			}
+
+			private int _Plat, _Gold;
+
+			public Mobile User { get; private set; }
+			public VirtualCheck Check { get; private set; }
+
+			public EditGump(Mobile user, VirtualCheck check)
+				: base(50, 50)
+			{
+				User = user;
+				Check = check;
+
+				_Plat = Check.Plat;
+				_Gold = Check.Gold;
+
+				Closable = true;
+				Disposable = true;
+				Dragable = true;
+				Resizable = false;
+
+				User.CloseGump(GetType());
+
+				CompileLayout();
+			}
+
+			public override void OnServerClose(NetState owner)
+			{
+				base.OnServerClose(owner);
+
+				if (Check != null && !Check.Deleted)
+				{
+					Check.UpdateTrade(User);
+				}
+			}
+
+			public void Close()
+			{
+				User.CloseGump(GetType());
+
+				if (Check != null && !Check.Deleted)
+				{
+					Check.UpdateTrade(User);
+				}
+				else
+				{
+					Check = null;
+				}
+			}
+
+			public void Send()
+			{
+				if (Check != null && !Check.Deleted)
+				{
+					User.SendGump(this);
+				}
+				else
+				{
+					Close();
+				}
+			}
+
+			public void Refresh(bool recompile)
+			{
+				if (Check == null || Check.Deleted)
+				{
+					Close();
+					return;
+				}
+
+				if (recompile)
+				{
+					CompileLayout();
+				}
+
+				Close();
+				Send();
+			}
+
+			private void CompileLayout()
+			{
+				if (Check == null || Check.Deleted)
+				{
+					return;
+				}
+
+				Entries.ForEach(e => e.Parent = null);
+				Entries.Clear();
+
+				AddPage(0);
+
+				AddBackground(0, 0, 400, 160, 3500);
+
+				// Title
+				AddImageTiled(25, 35, 350, 3, 96);
+				AddImage(10, 8, 113);
+				AddImage(360, 8, 113);
+
+				var title = String.Format(
+					"<BASEFONT COLOR=#{0:X6}><CENTER>BANK OF {1}</CENTER>",
+					Color.DarkSlateGray.ToArgb() & 0x00FFFFFF,
+					User.RawName.ToUpper());
+
+				AddHtml(40, 15, 320, 20, title, false, false);
+
+				// Platinum Row
+				AddBackground(15, 60, 175, 20, 9300);
+				AddBackground(20, 45, 165, 30, 9350);
+				AddItem(20, 45, 3826); // Plat
+				AddLabel(60, 50, 0, User.Account.TotalPlat.ToString("#,0"));
+
+				AddButton(195, 50, 95, 95, (int)Buttons.AllPlat, GumpButtonType.Reply, 0); // ->
+
+				AddBackground(210, 60, 175, 20, 9300);
+				AddBackground(215, 45, 165, 30, 9350);
+				AddTextEntry(225, 50, 145, 20, 0, 0, _Plat.ToString(), User.Account.TotalPlat.ToString().Length);
+
+				// Gold Row
+				AddBackground(15, 100, 175, 20, 9300);
+				AddBackground(20, 85, 165, 30, 9350);
+				AddItem(20, 85, 3823); // Gold
+				AddLabel(60, 90, 0, User.Account.TotalGold.ToString("#,0"));
+
+				AddButton(195, 90, 95, 95, (int)Buttons.AllGold, GumpButtonType.Reply, 0); // ->
+
+				AddBackground(210, 100, 175, 20, 9300);
+				AddBackground(215, 85, 165, 30, 9350);
+				AddTextEntry(225, 90, 145, 20, 0, 1, _Gold.ToString(), User.Account.TotalGold.ToString().Length);
+
+				// Buttons
+				AddButton(20, 128, 12006, 12007, (int)Buttons.Close, GumpButtonType.Reply, 0);
+				AddButton(215, 128, 12003, 12004, (int)Buttons.Clear, GumpButtonType.Reply, 0);
+				AddButton(305, 128, 12000, 12002, (int)Buttons.Accept, GumpButtonType.Reply, 0);
+			}
+
+			public override void OnResponse(NetState sender, RelayInfo info)
+			{
+				if (Check == null || Check.Deleted || sender.Mobile != User)
+				{
+					Close();
+					return;
+				}
+
+				bool refresh = false, updated = false;
+
+				switch ((Buttons)info.ButtonID)
+				{
+					case Buttons.Close:
+						break;
+					case Buttons.Clear:
+					{
+						_Plat = _Gold = 0;
+						refresh = true;
+					}
+						break;
+					case Buttons.Accept:
+					{
+						var platText = info.GetTextEntry(0).Text;
+						var goldText = info.GetTextEntry(1).Text;
+
+						if (!Int32.TryParse(platText, out _Plat))
+						{
+							User.SendMessage("That is not a valid amount of platinum.");
+							refresh = true;
+						}
+						else if (!Int32.TryParse(goldText, out _Gold))
+						{
+							User.SendMessage("That is not a valid amount of gold.");
+							refresh = true;
+						}
+						else
+						{
+							var cur = User.Account.TotalCurrency;
+							var off = _Plat + (_Gold / Math.Max(1.0, AccountGold.CurrencyThreshold));
+
+							if (off > cur)
+							{
+								_Plat = User.Account.TotalPlat;
+								_Gold = User.Account.TotalGold;
+								User.SendMessage("You do not have that much currency.");
+								refresh = true;
+							}
+							else
+							{
+								Check.Plat = _Plat;
+								Check.Gold = _Gold;
+								updated = true;
+							}
+						}
+					}
+						break;
+					case Buttons.AllPlat:
+					{
+						_Plat = User.Account.TotalPlat;
+						refresh = true;
+					}
+						break;
+					case Buttons.AllGold:
+					{
+						_Gold = User.Account.TotalGold;
+						refresh = true;
+					}
+						break;
+				}
+
+				if (updated)
+				{
+					User.SendMessage("Your offer has been updated.");
+				}
+
+				if (refresh && Check != null && !Check.Deleted)
+				{
+					Refresh(true);
+					return;
+				}
+
+				Close();
+			}
+		}
+	}
+}

Server/Items/VirtualHair.cs

@@ -0,0 +1,209 @@
+#region References
+using Server.Network;
+#endregion
+
+namespace Server
+{
+	public abstract class BaseHairInfo
+	{
+		private int m_ItemID;
+		private int m_Hue;
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public int ItemID { get { return m_ItemID; } set { m_ItemID = value; } }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public int Hue { get { return m_Hue; } set { m_Hue = value; } }
+
+		protected BaseHairInfo(int itemid)
+			: this(itemid, 0)
+		{ }
+
+		protected BaseHairInfo(int itemid, int hue)
+		{
+			m_ItemID = itemid;
+			m_Hue = hue;
+		}
+
+		protected BaseHairInfo(GenericReader reader)
+		{
+			int version = reader.ReadInt();
+
+			switch (version)
+			{
+				case 0:
+					{
+						m_ItemID = reader.ReadInt();
+						m_Hue = reader.ReadInt();
+						break;
+					}
+			}
+		}
+
+		public virtual void Serialize(GenericWriter writer)
+		{
+			writer.Write(0); //version
+			writer.Write(m_ItemID);
+			writer.Write(m_Hue);
+		}
+	}
+
+	public class HairInfo : BaseHairInfo
+	{
+		public HairInfo(int itemid)
+			: base(itemid, 0)
+		{ }
+
+		public HairInfo(int itemid, int hue)
+			: base(itemid, hue)
+		{ }
+
+		public HairInfo(GenericReader reader)
+			: base(reader)
+		{ }
+
+		public static int FakeSerial(Mobile parent)
+		{
+			return (0x7FFFFFFF - 0x400 - (parent.Serial * 4));
+		}
+	}
+
+	public class FacialHairInfo : BaseHairInfo
+	{
+		public FacialHairInfo(int itemid)
+			: base(itemid, 0)
+		{ }
+
+		public FacialHairInfo(int itemid, int hue)
+			: base(itemid, hue)
+		{ }
+
+		public FacialHairInfo(GenericReader reader)
+			: base(reader)
+		{ }
+
+		public static int FakeSerial(Mobile parent)
+		{
+			return (0x7FFFFFFF - 0x400 - 1 - (parent.Serial * 4));
+		}
+	}
+
+    public class FaceInfo : BaseHairInfo
+    {
+        public FaceInfo(int itemid)
+            : base(itemid, 0)
+        {
+        }
+
+        public FaceInfo(int itemid, int hue)
+            : base(itemid, hue)
+        {
+        }
+
+        public FaceInfo(GenericReader reader)
+            : base(reader)
+        {
+        }
+
+        public static int FakeSerial(Mobile parent)
+        {
+            return (0x7FFFFFFF - 0x400 - 2 - (parent.Serial * 4));
+        }
+    }
+
+    public sealed class HairEquipUpdate : Packet
+	{
+		public HairEquipUpdate(Mobile parent)
+			: base(0x2E, 15)
+		{
+			int hue = parent.HairHue;
+
+			if (parent.SolidHueOverride >= 0)
+			{
+				hue = parent.SolidHueOverride;
+			}
+
+			int hairSerial = HairInfo.FakeSerial(parent);
+
+			m_Stream.Write(hairSerial);
+			m_Stream.Write((short)parent.HairItemID);
+			m_Stream.Write((byte)0);
+			m_Stream.Write((byte)Layer.Hair);
+			m_Stream.Write(parent.Serial);
+			m_Stream.Write((short)hue);
+		}
+	}
+
+	public sealed class FacialHairEquipUpdate : Packet
+	{
+		public FacialHairEquipUpdate(Mobile parent)
+			: base(0x2E, 15)
+		{
+			int hue = parent.FacialHairHue;
+
+			if (parent.SolidHueOverride >= 0)
+			{
+				hue = parent.SolidHueOverride;
+			}
+
+			int hairSerial = FacialHairInfo.FakeSerial(parent);
+
+			m_Stream.Write(hairSerial);
+			m_Stream.Write((short)parent.FacialHairItemID);
+			m_Stream.Write((byte)0);
+			m_Stream.Write((byte)Layer.FacialHair);
+			m_Stream.Write(parent.Serial);
+			m_Stream.Write((short)hue);
+		}
+	}
+
+    public sealed class FaceEquipUpdate : Packet
+    {
+        public FaceEquipUpdate(Mobile parent)
+            : base(0x2E, 15)
+        {
+            int hue = parent.FaceHue;
+
+            if (parent.SolidHueOverride >= 0)
+            {
+                hue = parent.SolidHueOverride;
+            }
+
+            int faceSerial = FaceInfo.FakeSerial(parent);
+
+            m_Stream.Write((int)faceSerial);
+            m_Stream.Write((short)parent.FaceItemID);
+            m_Stream.Write((byte)0);
+            m_Stream.Write((byte)Layer.Face);
+            m_Stream.Write((int)parent.Serial);
+            m_Stream.Write((short)hue);
+        }
+    }
+
+    public sealed class RemoveHair : Packet
+	{
+		public RemoveHair(Mobile parent)
+			: base(0x1D, 5)
+		{
+			m_Stream.Write(HairInfo.FakeSerial(parent));
+		}
+	}
+
+	public sealed class RemoveFacialHair : Packet
+	{
+		public RemoveFacialHair(Mobile parent)
+			: base(0x1D, 5)
+		{
+			m_Stream.Write(FacialHairInfo.FakeSerial(parent));
+		}
+	}
+
+    public sealed class RemoveFace : Packet
+    {
+        public RemoveFace(Mobile parent)
+            : base(0x1D, 5)
+        {
+            m_Stream.Write((int)FaceInfo.FakeSerial(parent));
+        }
+    }
+}