Overwrite

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

Scripts/Gumps/Props/PropsConfig.cs

@@ -0,0 +1,42 @@
+namespace Server.Gumps
+{
+	public class PropsConfig
+	{
+		public static readonly bool OldStyle = false;
+
+		public static readonly int GumpOffsetX = 100;
+		public static readonly int GumpOffsetY = 30;
+
+		public static readonly int TextHue = 0;
+		public static readonly int TextOffsetX = 2;
+
+		public static readonly int OffsetGumpID = 0x0A40; // Pure black
+
+		// Light offwhite, textured : Dark navy blue, textured
+		public static readonly int HeaderGumpID = OldStyle ? 0x0BBC : 0x0E14; 
+
+		public static readonly int EntryGumpID = 0x0BBC; // Light offwhite, textured
+		public static readonly int BackGumpID = 0x13BE; // Gray slate/stoney
+		public static readonly int SetGumpID = OldStyle ? 0x0000 : 0x0E14; // Empty : Dark navy blue, textured
+
+		public static readonly int SetWidth = 20;
+		public static readonly int SetOffsetX = OldStyle ? 4 : 2, SetOffsetY = 2;
+		public static readonly int SetButtonID1 = 0x15E1; // Arrow pointing right
+		public static readonly int SetButtonID2 = 0x15E5; // " pressed
+
+		public static readonly int PrevWidth = 20;
+		public static readonly int PrevOffsetX = 2, PrevOffsetY = 2;
+		public static readonly int PrevButtonID1 = 0x15E3; // Arrow pointing left
+		public static readonly int PrevButtonID2 = 0x15E7; // " pressed
+
+		public static readonly int NextWidth = 20;
+		public static readonly int NextOffsetX = 2, NextOffsetY = 2;
+		public static readonly int NextButtonID1 = 0x15E1; // Arrow pointing right
+		public static readonly int NextButtonID2 = 0x15E5; // " pressed
+
+		public static readonly int OffsetSize = 1;
+
+		public static readonly int EntryHeight = 20;
+		public static readonly int BorderSize = 10;
+	}
+}

Scripts/Gumps/Props/SetBodyGump.cs

@@ -0,0 +1,316 @@
+#region References
+using System;
+using System.Collections;
+using System.Reflection;
+
+using Server.Commands;
+using Server.Network;
+#endregion
+
+namespace Server.Gumps
+{
+	public class SetBodyGump : Gump
+	{
+		private static ArrayList m_Monster, m_Animal, m_Sea, m_Human;
+		private const int LabelColor32 = 0xFFFFFF;
+		private const int SelectedColor32 = 0x8080FF;
+		private const int TextColor32 = 0xFFFFFF;
+		private readonly PropertyInfo m_Property;
+		private readonly Mobile m_Mobile;
+		private readonly object m_Object;
+		private readonly Stack m_Stack;
+		private readonly int m_Page;
+		private readonly ArrayList m_List;
+		private readonly int m_OurPage;
+		private readonly ArrayList m_OurList;
+		private readonly ModelBodyType m_OurType;
+
+		public SetBodyGump(PropertyInfo prop, Mobile mobile, object o, Stack stack, int page, ArrayList list)
+			: this(prop, mobile, o, stack, page, list, 0, null, ModelBodyType.Invalid)
+		{ }
+
+		public SetBodyGump(
+			PropertyInfo prop,
+			Mobile mobile,
+			object o,
+			Stack stack,
+			int page,
+			ArrayList list,
+			int ourPage,
+			ArrayList ourList,
+			ModelBodyType ourType)
+			: base(20, 30)
+		{
+			m_Property = prop;
+			m_Mobile = mobile;
+			m_Object = o;
+			m_Stack = stack;
+			m_Page = page;
+			m_List = list;
+			m_OurPage = ourPage;
+			m_OurList = ourList;
+			m_OurType = ourType;
+
+			AddPage(0);
+
+			AddBackground(0, 0, 525, 328, 5054);
+
+			AddImageTiled(10, 10, 505, 20, 0xA40);
+			AddAlphaRegion(10, 10, 505, 20);
+
+			AddImageTiled(10, 35, 505, 283, 0xA40);
+			AddAlphaRegion(10, 35, 505, 283);
+
+			AddTypeButton(10, 10, 1, "Monster", ModelBodyType.Monsters);
+			AddTypeButton(130, 10, 2, "Animal", ModelBodyType.Animals);
+			AddTypeButton(250, 10, 3, "Marine", ModelBodyType.Sea);
+			AddTypeButton(370, 10, 4, "Human", ModelBodyType.Human);
+
+			AddImage(480, 12, 0x25EA);
+			AddImage(497, 12, 0x25E6);
+
+			if (ourList == null)
+			{
+				AddLabel(15, 40, 0x480, "Choose a body type above.");
+			}
+			else if (ourList.Count == 0)
+			{
+				AddLabel(15, 40, 0x480, "The server must have UO:3D installed to use this feature.");
+			}
+			else
+			{
+				for (int i = 0, index = (ourPage * 12); i < 12 && index >= 0 && index < ourList.Count; ++i, ++index)
+				{
+					var entry = (InternalEntry)ourList[index];
+					var itemID = entry.ItemID;
+
+					var bounds = ItemBounds.Table[itemID & 0x3FFF];
+
+					var x = 15 + ((i % 4) * 125);
+					var y = 40 + ((i / 4) * 93);
+
+					AddItem(x + ((120 - bounds.Width) / 2) - bounds.X, y + ((69 - bounds.Height) / 2) - bounds.Y, itemID);
+					AddButton(x + 6, y + 66, 0x98D, 0x98D, 7 + index, GumpButtonType.Reply, 0);
+
+					x += 6;
+					y += 67;
+
+					AddHtml(x + 0, y - 1, 108, 21, Center(entry.DisplayName), false, false);
+					AddHtml(x + 0, y + 1, 108, 21, Center(entry.DisplayName), false, false);
+					AddHtml(x - 1, y + 0, 108, 21, Center(entry.DisplayName), false, false);
+					AddHtml(x + 1, y + 0, 108, 21, Center(entry.DisplayName), false, false);
+					AddHtml(x + 0, y + 0, 108, 21, Color(Center(entry.DisplayName), TextColor32), false, false);
+				}
+
+				if (ourPage > 0)
+					AddButton(480, 12, 0x15E3, 0x15E7, 5, GumpButtonType.Reply, 0);
+
+				if ((ourPage + 1) * 12 < ourList.Count)
+					AddButton(497, 12, 0x15E1, 0x15E5, 6, GumpButtonType.Reply, 0);
+			}
+		}
+
+		public string Center(string text)
+		{
+			return String.Format("<CENTER>{0}</CENTER>", text);
+		}
+
+		public string Color(string text, int color)
+		{
+			return String.Format("<BASEFONT COLOR=#{0:X6}>{1}</BASEFONT>", color, text);
+		}
+
+		public void AddTypeButton(int x, int y, int buttonID, string text, ModelBodyType type)
+		{
+			var isSelection = (m_OurType == type);
+
+			AddButton(x, y - 1, isSelection ? 4006 : 4005, 4007, buttonID, GumpButtonType.Reply, 0);
+			AddHtml(x + 35, y, 200, 20, Color(text, isSelection ? SelectedColor32 : LabelColor32), false, false);
+		}
+
+		public override void OnResponse(NetState sender, RelayInfo info)
+		{
+			var index = info.ButtonID - 1;
+
+			if (index == -1)
+			{
+				m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+			}
+			else if (index >= 0 && index < 4)
+			{
+				if (m_Monster == null)
+					LoadLists();
+
+				ModelBodyType type;
+				ArrayList list;
+
+				switch (index)
+				{
+					default:
+					case 0:
+						type = ModelBodyType.Monsters;
+						list = m_Monster;
+						break;
+					case 1:
+						type = ModelBodyType.Animals;
+						list = m_Animal;
+						break;
+					case 2:
+						type = ModelBodyType.Sea;
+						list = m_Sea;
+						break;
+					case 3:
+						type = ModelBodyType.Human;
+						list = m_Human;
+						break;
+				}
+
+				m_Mobile.SendGump(new SetBodyGump(m_Property, m_Mobile, m_Object, m_Stack, m_Page, m_List, 0, list, type));
+			}
+			else if (m_OurList != null)
+			{
+				index -= 4;
+
+				if (index == 0 && m_OurPage > 0)
+				{
+					m_Mobile.SendGump(
+						new SetBodyGump(m_Property, m_Mobile, m_Object, m_Stack, m_Page, m_List, m_OurPage - 1, m_OurList, m_OurType));
+				}
+				else if (index == 1 && ((m_OurPage + 1) * 12) < m_OurList.Count)
+				{
+					m_Mobile.SendGump(
+						new SetBodyGump(m_Property, m_Mobile, m_Object, m_Stack, m_Page, m_List, m_OurPage + 1, m_OurList, m_OurType));
+				}
+				else
+				{
+					index -= 2;
+
+					if (index >= 0 && index < m_OurList.Count)
+					{
+						try
+						{
+							var entry = (InternalEntry)m_OurList[index];
+
+							CommandLogging.LogChangeProperty(m_Mobile, m_Object, m_Property.Name, entry.Body.ToString());
+							m_Property.SetValue(m_Object, entry.Body, null);
+							PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+						}
+						catch
+						{
+							m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+						}
+
+						m_Mobile.SendGump(
+							new SetBodyGump(m_Property, m_Mobile, m_Object, m_Stack, m_Page, m_List, m_OurPage, m_OurList, m_OurType));
+					}
+				}
+			}
+		}
+
+		private static void LoadLists()
+		{
+			m_Monster = new ArrayList();
+			m_Animal = new ArrayList();
+			m_Sea = new ArrayList();
+			m_Human = new ArrayList();
+
+			var entries = Docs.LoadBodies();
+
+			for (var i = 0; i < entries.Count; ++i)
+			{
+				var oldEntry = entries[i];
+				var bodyID = oldEntry.Body.BodyID;
+
+				if (((Body)bodyID).IsEmpty)
+					continue;
+
+				ArrayList list = null;
+
+				switch (oldEntry.BodyType)
+				{
+					case ModelBodyType.Monsters:
+						list = m_Monster;
+						break;
+					case ModelBodyType.Animals:
+						list = m_Animal;
+						break;
+					case ModelBodyType.Sea:
+						list = m_Sea;
+						break;
+					case ModelBodyType.Human:
+						list = m_Human;
+						break;
+				}
+
+				if (list == null)
+					continue;
+
+				var itemID = ShrinkTable.Lookup(bodyID, -1);
+
+				if (itemID != -1)
+					list.Add(new InternalEntry(bodyID, itemID, oldEntry.Name));
+			}
+
+			m_Monster.Sort();
+			m_Animal.Sort();
+			m_Sea.Sort();
+			m_Human.Sort();
+		}
+
+		private class InternalEntry : IComparable
+		{
+			private static readonly string[] m_GroupNames =
+			{
+				"ogres_", "ettins_", "walking_dead_", "gargoyles_", "orcs_", "flails_", "daemons_", "arachnids_", "dragons_",
+				"elementals_", "serpents_", "gazers_", "liche_", "spirits_", "harpies_", "headless_", "lizard_race_", "mongbat_",
+				"rat_race_", "scorpions_", "trolls_", "slimes_", "skeletons_", "ethereals_", "terathan_", "imps_", "cyclops_",
+				"krakens_", "frogs_", "ophidians_", "centaurs_", "mages_", "fey_race_", "genies_", "paladins_", "shadowlords_",
+				"succubi_", "lizards_", "rodents_", "birds_", "bovines_", "bruins_", "canines_", "deer_", "equines_", "felines_",
+				"fowl_", "gorillas_", "kirin_", "llamas_", "ostards_", "porcines_", "ruminants_", "walrus_", "dolphins_",
+				"sea_horse_", "sea_serpents_", "character_", "h_", "titans_"
+			};
+
+			private readonly int m_Body;
+			private readonly int m_ItemID;
+			private readonly string m_Name;
+			private readonly string m_DisplayName;
+
+			public InternalEntry(int body, int itemID, string name)
+			{
+				m_Body = body;
+				m_ItemID = itemID;
+				m_Name = name;
+
+				m_DisplayName = name.ToLower();
+
+				for (var i = 0; i < m_GroupNames.Length; ++i)
+				{
+					if (m_DisplayName.StartsWith(m_GroupNames[i]))
+					{
+						m_DisplayName = m_DisplayName.Substring(m_GroupNames[i].Length);
+						break;
+					}
+				}
+
+				m_DisplayName = m_DisplayName.Replace('_', ' ');
+			}
+
+			public int Body { get { return m_Body; } }
+			public int ItemID { get { return m_ItemID; } }
+			public string Name { get { return m_Name; } }
+			public string DisplayName { get { return m_DisplayName; } }
+
+			public int CompareTo(object obj)
+			{
+				var comp = (InternalEntry)obj;
+
+				var v = m_Name.CompareTo(comp.m_Name);
+
+				if (v == 0)
+					m_Body.CompareTo(comp.m_Body);
+
+				return v;
+			}
+		}
+	}
+}

Scripts/Gumps/Props/SetColorGump.cs

@@ -0,0 +1,227 @@
+#region References
+using System;
+using System.Collections;
+using System.Drawing;
+using System.Globalization;
+using System.Reflection;
+
+using Server.Commands;
+using Server.Network;
+#endregion
+
+namespace Server.Gumps
+{
+	public class SetColorGump : Gump
+	{
+		private Color m_OldColor;
+		private readonly PropertyInfo m_Property;
+		private readonly Mobile m_Mobile;
+		private readonly object m_Object;
+		private readonly Stack m_Stack;
+		private readonly int m_Page;
+		private readonly ArrayList m_List;
+
+		public static readonly bool OldStyle = PropsConfig.OldStyle;
+
+		public static readonly int GumpOffsetX = PropsConfig.GumpOffsetX;
+		public static readonly int GumpOffsetY = PropsConfig.GumpOffsetY;
+
+		public static readonly int TextHue = PropsConfig.TextHue;
+		public static readonly int TextOffsetX = PropsConfig.TextOffsetX;
+
+		public static readonly int OffsetGumpID = PropsConfig.OffsetGumpID;
+		public static readonly int HeaderGumpID = PropsConfig.HeaderGumpID;
+		public static readonly int EntryGumpID = PropsConfig.EntryGumpID;
+		public static readonly int BackGumpID = PropsConfig.BackGumpID;
+		public static readonly int SetGumpID = PropsConfig.SetGumpID;
+
+		public static readonly int SetWidth = PropsConfig.SetWidth;
+		public static readonly int SetOffsetX = PropsConfig.SetOffsetX, SetOffsetY = PropsConfig.SetOffsetY;
+		public static readonly int SetButtonID1 = PropsConfig.SetButtonID1;
+		public static readonly int SetButtonID2 = PropsConfig.SetButtonID2;
+
+		public static readonly int PrevWidth = PropsConfig.PrevWidth;
+		public static readonly int PrevOffsetX = PropsConfig.PrevOffsetX, PrevOffsetY = PropsConfig.PrevOffsetY;
+		public static readonly int PrevButtonID1 = PropsConfig.PrevButtonID1;
+		public static readonly int PrevButtonID2 = PropsConfig.PrevButtonID2;
+
+		public static readonly int NextWidth = PropsConfig.NextWidth;
+		public static readonly int NextOffsetX = PropsConfig.NextOffsetX, NextOffsetY = PropsConfig.NextOffsetY;
+		public static readonly int NextButtonID1 = PropsConfig.NextButtonID1;
+		public static readonly int NextButtonID2 = PropsConfig.NextButtonID2;
+
+		public static readonly int OffsetSize = PropsConfig.OffsetSize;
+
+		public static readonly int EntryHeight = PropsConfig.EntryHeight;
+		public static readonly int BorderSize = PropsConfig.BorderSize;
+
+		private static readonly int EntryWidth = 212;
+
+		private static readonly int TotalWidth = OffsetSize + EntryWidth + OffsetSize + SetWidth + OffsetSize;
+		private static readonly int TotalHeight = OffsetSize + (6 * (EntryHeight + OffsetSize));
+
+		private static readonly int BackWidth = BorderSize + TotalWidth + BorderSize;
+		private static readonly int BackHeight = BorderSize + TotalHeight + BorderSize;
+
+		public SetColorGump(PropertyInfo prop, Mobile mobile, object o, Stack stack, int page, ArrayList list)
+			: base(GumpOffsetX, GumpOffsetY)
+		{
+			m_Property = prop;
+			m_Mobile = mobile;
+			m_Object = o;
+			m_Stack = stack;
+			m_Page = page;
+			m_List = list;
+
+			m_OldColor = (Color)prop.GetValue(o, null);
+
+			AddPage(0);
+
+			AddBackground(0, 0, BackWidth, BackHeight, BackGumpID);
+			AddImageTiled(
+				BorderSize,
+				BorderSize,
+				TotalWidth - (OldStyle ? SetWidth + OffsetSize : 0),
+				TotalHeight,
+				OffsetGumpID);
+
+			var name = m_OldColor.IsNamedColor ? m_OldColor.Name : m_OldColor.IsEmpty ? "Empty" : "";
+
+			var rgb = "#" + (m_OldColor.ToArgb() & 0x00FFFFFF).ToString("X6");
+
+			var val = String.Format("{0} ({1}) ({2},{3},{4})", name, rgb, m_OldColor.R, m_OldColor.G, m_OldColor.B);
+
+			AddRect(0, prop.Name, 0, -1);
+			AddRect(1, val, 0, -1);
+			AddRect(2, "Name:", 1, 0);
+			AddRect(3, "RGB:", 2, 1);
+			AddRect(4, "Hex:", 3, 2);
+			AddRect(5, "Empty", 4, -1);
+		}
+
+		private void AddRect(int index, string str, int button, int text)
+		{
+			var x = BorderSize + OffsetSize;
+			var y = BorderSize + OffsetSize + (index * (EntryHeight + OffsetSize));
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, str);
+
+			if (text != -1)
+			{
+				AddTextEntry(x + 40 + TextOffsetX, y, EntryWidth - TextOffsetX - 16, EntryHeight, TextHue, text, "");
+			}
+
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+			{
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+			}
+
+			if (button != 0)
+			{
+				AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, button, GumpButtonType.Reply, 0);
+			}
+		}
+
+		public override void OnResponse(NetState sender, RelayInfo info)
+		{
+			var toSet = Color.Empty;
+			var shouldSet = false;
+
+			var name = "";
+
+			if (info.ButtonID == 1)
+			{
+				name = info.GetTextEntry(0).Text;
+			}
+
+			var rgb = "";
+
+			if (info.ButtonID == 2)
+			{
+				rgb = info.GetTextEntry(1).Text;
+			}
+
+			var hex = "";
+
+			if (info.ButtonID == 3)
+			{
+				hex = info.GetTextEntry(2).Text;
+			}
+
+			switch (info.ButtonID)
+			{
+				case 1: // Name
+				{
+					var toapply = name != string.Empty
+						? name
+						: m_OldColor.IsNamedColor
+							? m_OldColor.Name
+							: m_OldColor.IsEmpty
+								? "Empty"
+								: "";
+
+					toSet = Color.FromName(toapply);
+
+					shouldSet = true;
+				}
+					break;
+				case 2: // RGB
+				{
+					var toapply = rgb != string.Empty ? rgb : String.Format("{0},{1},{2}", m_OldColor.R, m_OldColor.G, m_OldColor.B);
+
+					var args = toapply.Split(',');
+
+					if (args.Length >= 3)
+					{
+						byte r, g, b;
+
+						if (Byte.TryParse(args[0], out r) && Byte.TryParse(args[1], out g) && Byte.TryParse(args[2], out b))
+						{
+							toSet = Color.FromArgb(r, g, b);
+							shouldSet = true;
+						}
+					}
+				}
+					break;
+				case 3: // Hex
+				{
+					var toapply = hex != string.Empty ? hex : String.Format("#{0:X6}", m_OldColor.ToArgb() & 0x00FFFFFF);
+
+					int val;
+
+					if (Int32.TryParse(toapply.TrimStart('#'), NumberStyles.HexNumber, CultureInfo.CurrentCulture, out val))
+					{
+						toSet = Color.FromArgb(val);
+						shouldSet = true;
+					}
+				}
+					break;
+				case 4: // Empty
+				{
+					toSet = Color.Empty;
+					shouldSet = true;
+				}
+					break;
+			}
+
+			if (shouldSet)
+			{
+				try
+				{
+					CommandLogging.LogChangeProperty(m_Mobile, m_Object, m_Property.Name, toSet.ToString());
+					m_Property.SetValue(m_Object, toSet, null);
+					PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+				}
+				catch
+				{
+					m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+				}
+			}
+
+			m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+		}
+	}
+}

Scripts/Gumps/Props/SetCustomEnumGump.cs

@@ -0,0 +1,93 @@
+#region References
+using System;
+using System.Collections;
+using System.Reflection;
+
+using Server.Commands;
+using Server.Network;
+#endregion
+
+namespace Server.Gumps
+{
+	public class SetCustomEnumGump : SetListOptionGump
+	{
+		private static readonly Type typeofIDynamicEnum = typeof(IDynamicEnum);
+
+		private readonly string[] _Names;
+
+		public SetCustomEnumGump(
+			PropertyInfo prop,
+			Mobile mobile,
+			object o,
+			Stack stack,
+			int propspage,
+			ArrayList list,
+			string[] names)
+			: base(prop, mobile, o, stack, propspage, list, names, null)
+		{
+			_Names = names;
+		}
+
+		public override void OnResponse(NetState sender, RelayInfo relayInfo)
+		{
+			var index = relayInfo.ButtonID - 1;
+
+			if (index >= 0 && index < _Names.Length)
+			{
+				try
+				{
+					var info = m_Property.PropertyType.GetMethod("Parse", new[] {typeof(string)});
+
+					var result = "";
+
+					if (info != null)
+					{
+						result = Properties.SetDirect(
+							m_Mobile,
+							m_Object,
+							m_Object,
+							m_Property,
+							m_Property.Name,
+							info.Invoke(null, new object[] {_Names[index]}),
+							true);
+					}
+					else if (m_Property.PropertyType == typeof(Enum) || m_Property.PropertyType.IsSubclassOf(typeof(Enum)))
+					{
+						result = Properties.SetDirect(
+							m_Mobile,
+							m_Object,
+							m_Object,
+							m_Property,
+							m_Property.Name,
+							Enum.Parse(m_Property.PropertyType, _Names[index], false),
+							true);
+					}
+					else if (typeofIDynamicEnum.IsAssignableFrom(m_Property.PropertyType))
+					{
+						var ienum = (IDynamicEnum)m_Property.GetValue(m_Object, null);
+
+						if (ienum != null)
+						{
+							ienum.Value = _Names[index];
+						}
+
+						result = Properties.SetDirect(m_Mobile, m_Object, m_Object, m_Property, m_Property.Name, ienum, true);
+					}
+
+					m_Mobile.SendMessage(result);
+
+					if (result == "Property has been set.")
+					{
+						PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+					}
+				}
+				catch
+				{
+					m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+				}
+			}
+
+			m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+		}
+	}
+}

Scripts/Gumps/Props/SetDateTimeGump.cs

@@ -0,0 +1,243 @@
+#region References
+using System;
+using System.Collections;
+using System.Globalization;
+using System.Reflection;
+
+using Server.Commands;
+using Server.Network;
+#endregion
+
+namespace Server.Gumps
+{
+	public class SetDateTimeGump : Gump
+	{
+		private readonly DateTime m_OldDT;
+		private readonly PropertyInfo m_Property;
+		private readonly Mobile m_Mobile;
+		private readonly object m_Object;
+		private readonly Stack m_Stack;
+		private readonly int m_Page;
+		private readonly ArrayList m_List;
+
+		public static readonly bool OldStyle = PropsConfig.OldStyle;
+
+		public static readonly int GumpOffsetX = PropsConfig.GumpOffsetX;
+		public static readonly int GumpOffsetY = PropsConfig.GumpOffsetY;
+
+		public static readonly int TextHue = PropsConfig.TextHue;
+		public static readonly int TextOffsetX = PropsConfig.TextOffsetX;
+
+		public static readonly int OffsetGumpID = PropsConfig.OffsetGumpID;
+		public static readonly int HeaderGumpID = PropsConfig.HeaderGumpID;
+		public static readonly int EntryGumpID = PropsConfig.EntryGumpID;
+		public static readonly int BackGumpID = PropsConfig.BackGumpID;
+		public static readonly int SetGumpID = PropsConfig.SetGumpID;
+
+		public static readonly int SetWidth = PropsConfig.SetWidth;
+		public static readonly int SetOffsetX = PropsConfig.SetOffsetX, SetOffsetY = PropsConfig.SetOffsetY;
+		public static readonly int SetButtonID1 = PropsConfig.SetButtonID1;
+		public static readonly int SetButtonID2 = PropsConfig.SetButtonID2;
+
+		public static readonly int PrevWidth = PropsConfig.PrevWidth;
+		public static readonly int PrevOffsetX = PropsConfig.PrevOffsetX, PrevOffsetY = PropsConfig.PrevOffsetY;
+		public static readonly int PrevButtonID1 = PropsConfig.PrevButtonID1;
+		public static readonly int PrevButtonID2 = PropsConfig.PrevButtonID2;
+
+		public static readonly int NextWidth = PropsConfig.NextWidth;
+		public static readonly int NextOffsetX = PropsConfig.NextOffsetX, NextOffsetY = PropsConfig.NextOffsetY;
+		public static readonly int NextButtonID1 = PropsConfig.NextButtonID1;
+		public static readonly int NextButtonID2 = PropsConfig.NextButtonID2;
+
+		public static readonly int OffsetSize = PropsConfig.OffsetSize;
+
+		public static readonly int EntryHeight = PropsConfig.EntryHeight;
+		public static readonly int BorderSize = PropsConfig.BorderSize;
+
+		private static readonly int EntryWidth = 212;
+
+		private static readonly int TotalWidth = OffsetSize + EntryWidth + OffsetSize + SetWidth + OffsetSize;
+		private static readonly int TotalHeight = OffsetSize + (12 * (EntryHeight + OffsetSize));
+
+		private static readonly int BackWidth = BorderSize + TotalWidth + BorderSize;
+		private static readonly int BackHeight = BorderSize + TotalHeight + BorderSize;
+
+		public SetDateTimeGump(PropertyInfo prop, Mobile mobile, object o, Stack stack, int page, ArrayList list)
+			: base(GumpOffsetX, GumpOffsetY)
+		{
+			m_Property = prop;
+			m_Mobile = mobile;
+			m_Object = o;
+			m_Stack = stack;
+			m_Page = page;
+			m_List = list;
+
+			m_OldDT = (DateTime)prop.GetValue(o, null);
+
+			AddPage(0);
+
+			AddBackground(0, 0, BackWidth, BackHeight, BackGumpID);
+			AddImageTiled(
+				BorderSize,
+				BorderSize,
+				TotalWidth - (OldStyle ? SetWidth + OffsetSize : 0),
+				TotalHeight,
+				OffsetGumpID);
+
+			AddRect(0, prop.Name, 0, -1);
+			AddRect(1, String.Format("{0:u}", m_OldDT), 0, -1);
+			AddRect(2, "MinValue", 1, -1);
+			AddRect(3, "From YYYY:MM:DD hh:mm", 2, -1);
+			AddRect(4, "From YYYY:MM:DD", 3, -1);
+			AddRect(5, "From hh:mm", 4, -1);
+			AddRect(6, "Year:", 5, 0);
+			AddRect(7, "Month:", 6, 1);
+			AddRect(8, "Day:", 7, 2);
+			AddRect(9, "Hour:", 8, 3);
+			AddRect(10, "Minute:", 9, 4);
+			AddRect(11, "MaxValue", 10, -1);
+		}
+
+		private void AddRect(int index, string str, int button, int text)
+		{
+			var x = BorderSize + OffsetSize;
+			var y = BorderSize + OffsetSize + (index * (EntryHeight + OffsetSize));
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, str);
+
+			if (text != -1)
+			{
+				AddTextEntry(x + 40 + TextOffsetX, y, EntryWidth - TextOffsetX - 16, EntryHeight, TextHue, text, "");
+			}
+
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+			{
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+			}
+
+			if (button != 0)
+			{
+				AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, button, GumpButtonType.Reply, 0);
+			}
+		}
+
+		public override void OnResponse(NetState sender, RelayInfo info)
+		{
+			DateTime toSet;
+			bool shouldSet, shouldSend;
+
+			var year = "";
+
+			if (info.ButtonID == 2 || info.ButtonID == 3 || info.ButtonID == 5)
+			{
+				year = info.GetTextEntry(0).Text;
+			}
+
+			var month = "";
+
+			if (info.ButtonID == 2 || info.ButtonID == 3 || info.ButtonID == 6)
+			{
+				month = info.GetTextEntry(1).Text;
+			}
+
+			var day = "";
+
+			if (info.ButtonID == 2 || info.ButtonID == 3 || info.ButtonID == 7)
+			{
+				day = info.GetTextEntry(2).Text;
+			}
+
+			var hour = "";
+
+			if (info.ButtonID == 2 || info.ButtonID == 4 || info.ButtonID == 8)
+			{
+				hour = info.GetTextEntry(3).Text;
+			}
+
+			var min = "";
+
+			if (info.ButtonID == 2 || info.ButtonID == 4 || info.ButtonID == 9)
+			{
+				min = info.GetTextEntry(4).Text;
+			}
+
+			switch (info.ButtonID)
+			{
+				case 1: // MinValue
+				{
+					toSet = DateTime.MinValue;
+					shouldSet = true;
+					shouldSend = true;
+
+					break;
+				}
+				case 2: // From YYYY MM DD H:M
+				{
+					var successfulParse = false;
+					var toapply = String.Format(
+						"{0}/{1}/{2} {3}:{4}:00",
+						(year != string.Empty ? year : String.Format("{0:yyyy}", m_OldDT)),
+						(month != string.Empty ? month : String.Format("{0:MM}", m_OldDT)),
+						(day != string.Empty ? day : String.Format("{0:dd}", m_OldDT)),
+						(hour != string.Empty ? hour : String.Format("{0:HH}", m_OldDT)),
+						(min != string.Empty ? min : String.Format("{0:mm}", m_OldDT)));
+					successfulParse = DateTime.TryParse(toapply, out toSet);
+
+					shouldSet = shouldSend = successfulParse;
+
+					break;
+				}
+				case 3:
+				case 4:
+				case 5:
+				case 6:
+				case 7:
+				case 8:
+				case 9:
+					goto case 2;
+				case 10:
+				{
+					toSet = DateTime.MaxValue;
+					shouldSet = true;
+					shouldSend = true;
+
+					break;
+				}
+				default:
+				{
+					toSet = DateTime.MinValue;
+					shouldSet = false;
+					shouldSend = true;
+
+					break;
+				}
+			}
+
+			if (shouldSet)
+			{
+				try
+				{
+					CommandLogging.LogChangeProperty(
+						m_Mobile,
+						m_Object,
+						m_Property.Name,
+						toSet.ToString(CultureInfo.InvariantCulture));
+					m_Property.SetValue(m_Object, toSet, null);
+					PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+				}
+				catch
+				{
+					m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+				}
+			}
+
+			if (shouldSend)
+			{
+				m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+			}
+		}
+	}
+}

Scripts/Gumps/Props/SetGump.cs

@@ -0,0 +1,284 @@
+#region References
+using System.Collections;
+using System.Reflection;
+
+using Server.Commands;
+using Server.HuePickers;
+using Server.Network;
+#endregion
+
+namespace Server.Gumps
+{
+	public class SetGump : Gump
+	{
+		public static readonly bool OldStyle = PropsConfig.OldStyle;
+		public static readonly int GumpOffsetX = PropsConfig.GumpOffsetX;
+		public static readonly int GumpOffsetY = PropsConfig.GumpOffsetY;
+		public static readonly int TextHue = PropsConfig.TextHue;
+		public static readonly int TextOffsetX = PropsConfig.TextOffsetX;
+		public static readonly int OffsetGumpID = PropsConfig.OffsetGumpID;
+		public static readonly int HeaderGumpID = PropsConfig.HeaderGumpID;
+		public static readonly int EntryGumpID = PropsConfig.EntryGumpID;
+		public static readonly int BackGumpID = PropsConfig.BackGumpID;
+		public static readonly int SetGumpID = PropsConfig.SetGumpID;
+		public static readonly int SetWidth = PropsConfig.SetWidth;
+		public static readonly int SetOffsetX = PropsConfig.SetOffsetX, SetOffsetY = PropsConfig.SetOffsetY;
+		public static readonly int SetButtonID1 = PropsConfig.SetButtonID1;
+		public static readonly int SetButtonID2 = PropsConfig.SetButtonID2;
+		public static readonly int PrevWidth = PropsConfig.PrevWidth;
+		public static readonly int PrevOffsetX = PropsConfig.PrevOffsetX, PrevOffsetY = PropsConfig.PrevOffsetY;
+		public static readonly int PrevButtonID1 = PropsConfig.PrevButtonID1;
+		public static readonly int PrevButtonID2 = PropsConfig.PrevButtonID2;
+		public static readonly int NextWidth = PropsConfig.NextWidth;
+		public static readonly int NextOffsetX = PropsConfig.NextOffsetX, NextOffsetY = PropsConfig.NextOffsetY;
+		public static readonly int NextButtonID1 = PropsConfig.NextButtonID1;
+		public static readonly int NextButtonID2 = PropsConfig.NextButtonID2;
+		public static readonly int OffsetSize = PropsConfig.OffsetSize;
+		public static readonly int EntryHeight = PropsConfig.EntryHeight;
+		public static readonly int BorderSize = PropsConfig.BorderSize;
+		private static readonly int EntryWidth = 212;
+		private static readonly int TotalWidth = OffsetSize + EntryWidth + OffsetSize + SetWidth + OffsetSize;
+		private static readonly int TotalHeight = OffsetSize + (2 * (EntryHeight + OffsetSize));
+		private static readonly int BackWidth = BorderSize + TotalWidth + BorderSize;
+		private static readonly int BackHeight = BorderSize + TotalHeight + BorderSize;
+		private readonly PropertyInfo m_Property;
+		private readonly Mobile m_Mobile;
+		private readonly object m_Object;
+		private readonly Stack m_Stack;
+		private readonly int m_Page;
+		private readonly ArrayList m_List;
+
+		public SetGump(PropertyInfo prop, Mobile mobile, object o, Stack stack, int page, ArrayList list)
+			: base(GumpOffsetX, GumpOffsetY)
+		{
+			m_Property = prop;
+			m_Mobile = mobile;
+			m_Object = o;
+			m_Stack = stack;
+			m_Page = page;
+			m_List = list;
+
+			var canNull = !prop.PropertyType.IsValueType;
+			var canDye = prop.IsDefined(typeof(HueAttribute), false);
+			var isBody = prop.IsDefined(typeof(BodyAttribute), false);
+
+			var val = prop.GetValue(m_Object, null);
+			string initialText;
+
+			if (val == null)
+				initialText = "";
+			else if (val is TextDefinition)
+				initialText = ((TextDefinition)val).GetValue();
+			else
+				initialText = val.ToString();
+
+			AddPage(0);
+
+			AddBackground(
+				0,
+				0,
+				BackWidth,
+				BackHeight + (canNull ? (EntryHeight + OffsetSize) : 0) + (canDye ? (EntryHeight + OffsetSize) : 0) +
+				(isBody ? (EntryHeight + OffsetSize) : 0),
+				BackGumpID);
+			AddImageTiled(
+				BorderSize,
+				BorderSize,
+				TotalWidth - (OldStyle ? SetWidth + OffsetSize : 0),
+				TotalHeight + (canNull ? (EntryHeight + OffsetSize) : 0) + (canDye ? (EntryHeight + OffsetSize) : 0) +
+				(isBody ? (EntryHeight + OffsetSize) : 0),
+				OffsetGumpID);
+
+			var x = BorderSize + OffsetSize;
+			var y = BorderSize + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, prop.Name);
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+			x = BorderSize + OffsetSize;
+			y += EntryHeight + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddTextEntry(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, 0, initialText);
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+			AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 1, GumpButtonType.Reply, 0);
+
+			if (canNull)
+			{
+				x = BorderSize + OffsetSize;
+				y += EntryHeight + OffsetSize;
+
+				AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+				AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, "Null");
+				x += EntryWidth + OffsetSize;
+
+				if (SetGumpID != 0)
+					AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+				AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 2, GumpButtonType.Reply, 0);
+			}
+
+			if (canDye)
+			{
+				x = BorderSize + OffsetSize;
+				y += EntryHeight + OffsetSize;
+
+				AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+				AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, "Hue Picker");
+				x += EntryWidth + OffsetSize;
+
+				if (SetGumpID != 0)
+					AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+				AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 3, GumpButtonType.Reply, 0);
+			}
+
+			if (isBody)
+			{
+				x = BorderSize + OffsetSize;
+				y += EntryHeight + OffsetSize;
+
+				AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+				AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, "Body Picker");
+				x += EntryWidth + OffsetSize;
+
+				if (SetGumpID != 0)
+					AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+				AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 4, GumpButtonType.Reply, 0);
+			}
+		}
+
+		public override void OnResponse(NetState sender, RelayInfo info)
+		{
+			object toSet;
+			bool shouldSet, shouldSend = true;
+
+			switch (info.ButtonID)
+			{
+				case 1:
+				{
+					var text = info.GetTextEntry(0);
+
+					if (text != null)
+					{
+						try
+						{
+							toSet = PropertiesGump.GetObjectFromString(m_Property.PropertyType, text.Text);
+							shouldSet = true;
+						}
+						catch
+						{
+							toSet = null;
+							shouldSet = false;
+							m_Mobile.SendMessage("Bad format");
+						}
+					}
+					else
+					{
+						toSet = null;
+						shouldSet = false;
+					}
+
+					break;
+				}
+				case 2: // Null
+				{
+					toSet = null;
+					shouldSet = true;
+
+					break;
+				}
+				case 3: // Hue Picker
+				{
+					toSet = null;
+					shouldSet = false;
+					shouldSend = false;
+
+					m_Mobile.SendHuePicker(new InternalPicker(m_Property, m_Mobile, m_Object, m_Stack, m_Page, m_List));
+
+					break;
+				}
+				case 4: // Body Picker
+				{
+					toSet = null;
+					shouldSet = false;
+					shouldSend = false;
+
+					m_Mobile.SendGump(new SetBodyGump(m_Property, m_Mobile, m_Object, m_Stack, m_Page, m_List));
+
+					break;
+				}
+				default:
+				{
+					toSet = null;
+					shouldSet = false;
+
+					break;
+				}
+			}
+
+			if (shouldSet)
+			{
+				try
+				{
+					CommandLogging.LogChangeProperty(m_Mobile, m_Object, m_Property.Name, toSet == null ? "(null)" : toSet.ToString());
+					m_Property.SetValue(m_Object, toSet, null);
+					PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+				}
+				catch
+				{
+					m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+				}
+			}
+
+			if (shouldSend)
+				m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+		}
+
+		private class InternalPicker : HuePicker
+		{
+			private readonly PropertyInfo m_Property;
+			private readonly Mobile m_Mobile;
+			private readonly object m_Object;
+			private readonly Stack m_Stack;
+			private readonly int m_Page;
+			private readonly ArrayList m_List;
+
+			public InternalPicker(PropertyInfo prop, Mobile mobile, object o, Stack stack, int page, ArrayList list)
+				: base(((IHued)o).HuedItemID)
+			{
+				m_Property = prop;
+				m_Mobile = mobile;
+				m_Object = o;
+				m_Stack = stack;
+				m_Page = page;
+				m_List = list;
+			}
+
+			public override void OnResponse(int hue)
+			{
+				try
+				{
+					CommandLogging.LogChangeProperty(m_Mobile, m_Object, m_Property.Name, hue.ToString());
+					m_Property.SetValue(m_Object, hue, null);
+					PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+				}
+				catch
+				{
+					m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+				}
+
+				m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+			}
+		}
+	}
+}

Scripts/Gumps/Props/SetListOptionGump.cs

@@ -0,0 +1,208 @@
+#region References
+using System.Collections;
+using System.Reflection;
+
+using Server.Commands;
+using Server.Network;
+#endregion
+
+namespace Server.Gumps
+{
+	public class SetListOptionGump : Gump
+	{
+		public static readonly bool OldStyle = PropsConfig.OldStyle;
+		public static readonly int GumpOffsetX = PropsConfig.GumpOffsetX;
+		public static readonly int GumpOffsetY = PropsConfig.GumpOffsetY;
+		public static readonly int TextHue = PropsConfig.TextHue;
+		public static readonly int TextOffsetX = PropsConfig.TextOffsetX;
+		public static readonly int OffsetGumpID = PropsConfig.OffsetGumpID;
+		public static readonly int HeaderGumpID = PropsConfig.HeaderGumpID;
+		public static readonly int EntryGumpID = PropsConfig.EntryGumpID;
+		public static readonly int BackGumpID = PropsConfig.BackGumpID;
+		public static readonly int SetGumpID = PropsConfig.SetGumpID;
+		public static readonly int SetWidth = PropsConfig.SetWidth;
+		public static readonly int SetOffsetX = PropsConfig.SetOffsetX, SetOffsetY = PropsConfig.SetOffsetY;
+		public static readonly int SetButtonID1 = PropsConfig.SetButtonID1;
+		public static readonly int SetButtonID2 = PropsConfig.SetButtonID2;
+		public static readonly int PrevWidth = PropsConfig.PrevWidth;
+		public static readonly int PrevOffsetX = PropsConfig.PrevOffsetX, PrevOffsetY = PropsConfig.PrevOffsetY;
+		public static readonly int PrevButtonID1 = PropsConfig.PrevButtonID1;
+		public static readonly int PrevButtonID2 = PropsConfig.PrevButtonID2;
+		public static readonly int NextWidth = PropsConfig.NextWidth;
+		public static readonly int NextOffsetX = PropsConfig.NextOffsetX, NextOffsetY = PropsConfig.NextOffsetY;
+		public static readonly int NextButtonID1 = PropsConfig.NextButtonID1;
+		public static readonly int NextButtonID2 = PropsConfig.NextButtonID2;
+		public static readonly int OffsetSize = PropsConfig.OffsetSize;
+		public static readonly int EntryHeight = PropsConfig.EntryHeight;
+		public static readonly int BorderSize = PropsConfig.BorderSize;
+
+		private static readonly int EntryWidth = 212;
+		private static readonly int EntryCount = 13;
+		private static readonly int TotalWidth = OffsetSize + EntryWidth + OffsetSize + SetWidth + OffsetSize;
+		private static readonly int BackWidth = BorderSize + TotalWidth + BorderSize;
+		private static readonly bool PrevLabel = OldStyle;
+		private static readonly bool NextLabel = OldStyle;
+		private static readonly int PrevLabelOffsetX = PrevWidth + 1;
+		private static readonly int PrevLabelOffsetY = 0;
+		private static readonly int NextLabelOffsetX = -29;
+		private static readonly int NextLabelOffsetY = 0;
+
+		protected PropertyInfo m_Property;
+		protected Mobile m_Mobile;
+		protected object m_Object;
+		protected Stack m_Stack;
+		protected int m_Page;
+		protected ArrayList m_List;
+		protected object[] m_Values;
+
+		public SetListOptionGump(
+			PropertyInfo prop,
+			Mobile mobile,
+			object o,
+			Stack stack,
+			int propspage,
+			ArrayList list,
+			string[] names,
+			object[] values)
+			: base(GumpOffsetX, GumpOffsetY)
+		{
+			m_Property = prop;
+			m_Mobile = mobile;
+			m_Object = o;
+			m_Stack = stack;
+			m_Page = propspage;
+			m_List = list;
+
+			m_Values = values;
+
+			var pages = (names.Length + EntryCount - 1) / EntryCount;
+			var index = 0;
+
+			for (var page = 1; page <= pages; ++page)
+			{
+				AddPage(page);
+
+				var start = (page - 1) * EntryCount;
+				var count = names.Length - start;
+
+				if (count > EntryCount)
+				{
+					count = EntryCount;
+				}
+
+				var totalHeight = OffsetSize + ((count + 2) * (EntryHeight + OffsetSize));
+				var backHeight = BorderSize + totalHeight + BorderSize;
+
+				AddBackground(0, 0, BackWidth, backHeight, BackGumpID);
+				AddImageTiled(
+					BorderSize,
+					BorderSize,
+					TotalWidth - (OldStyle ? SetWidth + OffsetSize : 0),
+					totalHeight,
+					OffsetGumpID);
+
+				var x = BorderSize + OffsetSize;
+				var y = BorderSize + OffsetSize;
+
+				var emptyWidth = TotalWidth - PrevWidth - NextWidth - (OffsetSize * 4) - (OldStyle ? SetWidth + OffsetSize : 0);
+
+				AddImageTiled(x, y, PrevWidth, EntryHeight, HeaderGumpID);
+
+				if (page > 1)
+				{
+					AddButton(x + PrevOffsetX, y + PrevOffsetY, PrevButtonID1, PrevButtonID2, 0, GumpButtonType.Page, page - 1);
+
+					if (PrevLabel)
+					{
+						AddLabel(x + PrevLabelOffsetX, y + PrevLabelOffsetY, TextHue, "Previous");
+					}
+				}
+
+				x += PrevWidth + OffsetSize;
+
+				if (!OldStyle)
+				{
+					AddImageTiled(
+						x - (OldStyle ? OffsetSize : 0),
+						y,
+						emptyWidth + (OldStyle ? OffsetSize * 2 : 0),
+						EntryHeight,
+						HeaderGumpID);
+				}
+
+				x += emptyWidth + OffsetSize;
+
+				if (!OldStyle)
+				{
+					AddImageTiled(x, y, NextWidth, EntryHeight, HeaderGumpID);
+				}
+
+				if (page < pages)
+				{
+					AddButton(x + NextOffsetX, y + NextOffsetY, NextButtonID1, NextButtonID2, 0, GumpButtonType.Page, page + 1);
+
+					if (NextLabel)
+					{
+						AddLabel(x + NextLabelOffsetX, y + NextLabelOffsetY, TextHue, "Next");
+					}
+				}
+
+				AddRect(0, prop.Name, 0);
+
+				for (var i = 0; i < count; ++i)
+				{
+					AddRect(i + 1, names[index], ++index);
+				}
+			}
+		}
+
+		public override void OnResponse(NetState sender, RelayInfo info)
+		{
+			var index = info.ButtonID - 1;
+
+			if (index >= 0 && index < m_Values.Length)
+			{
+				try
+				{
+					var toSet = m_Values[index];
+
+					var result = Properties.SetDirect(m_Mobile, m_Object, m_Object, m_Property, m_Property.Name, toSet, true);
+
+					m_Mobile.SendMessage(result);
+
+					if (result == "Property has been set.")
+					{
+						PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+					}
+				}
+				catch
+				{
+					m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+				}
+			}
+
+			m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+		}
+
+		private void AddRect(int index, string str, int button)
+		{
+			var x = BorderSize + OffsetSize;
+			var y = BorderSize + OffsetSize + ((index + 1) * (EntryHeight + OffsetSize));
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, str);
+
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+			{
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+			}
+
+			if (button != 0)
+			{
+				AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, button, GumpButtonType.Reply, 0);
+			}
+		}
+	}
+}

Scripts/Gumps/Props/SetObjectGump.cs

@@ -0,0 +1,310 @@
+#region References
+using System;
+using System.Collections;
+using System.Reflection;
+
+using Server.Commands;
+using Server.Commands.Generic;
+using Server.Network;
+using Server.Prompts;
+#endregion
+
+namespace Server.Gumps
+{
+	public class SetObjectGump : Gump
+	{
+		public static readonly bool OldStyle = PropsConfig.OldStyle;
+		public static readonly int GumpOffsetX = PropsConfig.GumpOffsetX;
+		public static readonly int GumpOffsetY = PropsConfig.GumpOffsetY;
+		public static readonly int TextHue = PropsConfig.TextHue;
+		public static readonly int TextOffsetX = PropsConfig.TextOffsetX;
+		public static readonly int OffsetGumpID = PropsConfig.OffsetGumpID;
+		public static readonly int HeaderGumpID = PropsConfig.HeaderGumpID;
+		public static readonly int EntryGumpID = PropsConfig.EntryGumpID;
+		public static readonly int BackGumpID = PropsConfig.BackGumpID;
+		public static readonly int SetGumpID = PropsConfig.SetGumpID;
+		public static readonly int SetWidth = PropsConfig.SetWidth;
+		public static readonly int SetOffsetX = PropsConfig.SetOffsetX, SetOffsetY = PropsConfig.SetOffsetY;
+		public static readonly int SetButtonID1 = PropsConfig.SetButtonID1;
+		public static readonly int SetButtonID2 = PropsConfig.SetButtonID2;
+		public static readonly int PrevWidth = PropsConfig.PrevWidth;
+		public static readonly int PrevOffsetX = PropsConfig.PrevOffsetX, PrevOffsetY = PropsConfig.PrevOffsetY;
+		public static readonly int PrevButtonID1 = PropsConfig.PrevButtonID1;
+		public static readonly int PrevButtonID2 = PropsConfig.PrevButtonID2;
+		public static readonly int NextWidth = PropsConfig.NextWidth;
+		public static readonly int NextOffsetX = PropsConfig.NextOffsetX, NextOffsetY = PropsConfig.NextOffsetY;
+		public static readonly int NextButtonID1 = PropsConfig.NextButtonID1;
+		public static readonly int NextButtonID2 = PropsConfig.NextButtonID2;
+		public static readonly int OffsetSize = PropsConfig.OffsetSize;
+		public static readonly int EntryHeight = PropsConfig.EntryHeight;
+		public static readonly int BorderSize = PropsConfig.BorderSize;
+		private static readonly int EntryWidth = 212;
+		private static readonly int TotalWidth = OffsetSize + EntryWidth + OffsetSize + SetWidth + OffsetSize;
+		private static readonly int TotalHeight = OffsetSize + (5 * (EntryHeight + OffsetSize));
+		private static readonly int BackWidth = BorderSize + TotalWidth + BorderSize;
+		private static readonly int BackHeight = BorderSize + TotalHeight + BorderSize;
+		private readonly PropertyInfo m_Property;
+		private readonly Mobile m_Mobile;
+		private readonly object m_Object;
+		private readonly Stack m_Stack;
+		private readonly Type m_Type;
+		private readonly int m_Page;
+		private readonly ArrayList m_List;
+
+		public SetObjectGump(PropertyInfo prop, Mobile mobile, object o, Stack stack, Type type, int page, ArrayList list)
+			: base(GumpOffsetX, GumpOffsetY)
+		{
+			m_Property = prop;
+			m_Mobile = mobile;
+			m_Object = o;
+			m_Stack = stack;
+			m_Type = type;
+			m_Page = page;
+			m_List = list;
+
+			var initialText = PropertiesGump.ValueToString(o, prop);
+
+			AddPage(0);
+
+			AddBackground(0, 0, BackWidth, BackHeight, BackGumpID);
+			AddImageTiled(
+				BorderSize,
+				BorderSize,
+				TotalWidth - (OldStyle ? SetWidth + OffsetSize : 0),
+				TotalHeight,
+				OffsetGumpID);
+
+			var x = BorderSize + OffsetSize;
+			var y = BorderSize + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, prop.Name);
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+			x = BorderSize + OffsetSize;
+			y += EntryHeight + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, initialText);
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+			AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 1, GumpButtonType.Reply, 0);
+
+			x = BorderSize + OffsetSize;
+			y += EntryHeight + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, "Change by Serial");
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+			AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 2, GumpButtonType.Reply, 0);
+
+			x = BorderSize + OffsetSize;
+			y += EntryHeight + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, "Nullify");
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+			AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 3, GumpButtonType.Reply, 0);
+
+			x = BorderSize + OffsetSize;
+			y += EntryHeight + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, "View Properties");
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+			AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 4, GumpButtonType.Reply, 0);
+		}
+
+		public override void OnResponse(NetState sender, RelayInfo info)
+		{
+			object toSet;
+			bool shouldSet, shouldSend = true;
+			object viewProps = null;
+
+			switch (info.ButtonID)
+			{
+				case 0: // closed
+				{
+					m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+
+					toSet = null;
+					shouldSet = false;
+					shouldSend = false;
+
+					break;
+				}
+				case 1: // Change by Target
+				{
+					m_Mobile.Target = new SetObjectTarget(m_Property, m_Mobile, m_Object, m_Stack, m_Type, m_Page, m_List);
+					toSet = null;
+					shouldSet = false;
+					shouldSend = false;
+					break;
+				}
+				case 2: // Change by Serial
+				{
+					toSet = null;
+					shouldSet = false;
+					shouldSend = false;
+
+					m_Mobile.SendMessage("Enter the serial you wish to find:");
+					m_Mobile.Prompt = new InternalPrompt(m_Property, m_Mobile, m_Object, m_Stack, m_Type, m_Page, m_List);
+
+					break;
+				}
+				case 3: // Nullify
+				{
+					toSet = null;
+					shouldSet = true;
+
+					break;
+				}
+				case 4: // View Properties
+				{
+					toSet = null;
+					shouldSet = false;
+
+					var obj = m_Property.GetValue(m_Object, null);
+
+					if (obj == null)
+						m_Mobile.SendMessage("The property is null and so you cannot view its properties.");
+					else if (!BaseCommand.IsAccessible(m_Mobile, obj))
+						m_Mobile.SendMessage("You may not view their properties.");
+					else
+						viewProps = obj;
+
+					break;
+				}
+				default:
+				{
+					toSet = null;
+					shouldSet = false;
+
+					break;
+				}
+			}
+
+			if (shouldSet)
+			{
+				try
+				{
+					CommandLogging.LogChangeProperty(m_Mobile, m_Object, m_Property.Name, toSet == null ? "(null)" : toSet.ToString());
+					m_Property.SetValue(m_Object, toSet, null);
+					PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+				}
+				catch
+				{
+					m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+				}
+			}
+
+			if (shouldSend)
+				m_Mobile.SendGump(new SetObjectGump(m_Property, m_Mobile, m_Object, m_Stack, m_Type, m_Page, m_List));
+
+			if (viewProps != null)
+				m_Mobile.SendGump(new PropertiesGump(m_Mobile, viewProps));
+		}
+
+		private class InternalPrompt : Prompt
+		{
+			private readonly PropertyInfo m_Property;
+			private readonly Mobile m_Mobile;
+			private readonly object m_Object;
+			private readonly Stack m_Stack;
+			private readonly Type m_Type;
+			private readonly int m_Page;
+			private readonly ArrayList m_List;
+
+			public InternalPrompt(PropertyInfo prop, Mobile mobile, object o, Stack stack, Type type, int page, ArrayList list)
+			{
+				m_Property = prop;
+				m_Mobile = mobile;
+				m_Object = o;
+				m_Stack = stack;
+				m_Type = type;
+				m_Page = page;
+				m_List = list;
+			}
+
+			public override void OnCancel(Mobile from)
+			{
+				m_Mobile.SendGump(new SetObjectGump(m_Property, m_Mobile, m_Object, m_Stack, m_Type, m_Page, m_List));
+			}
+
+			public override void OnResponse(Mobile from, string text)
+			{
+				object toSet;
+				bool shouldSet;
+
+				try
+				{
+					var serial = Utility.ToInt32(text);
+
+					toSet = World.FindEntity(serial);
+
+					if (toSet == null)
+					{
+						shouldSet = false;
+						m_Mobile.SendMessage("No object with that serial was found.");
+					}
+					else if (!m_Type.IsAssignableFrom(toSet.GetType()))
+					{
+						toSet = null;
+						shouldSet = false;
+						m_Mobile.SendMessage(
+							"The object with that serial could not be assigned to a property of type : {0}",
+							m_Type.Name);
+					}
+					else
+					{
+						shouldSet = true;
+					}
+				}
+				catch
+				{
+					toSet = null;
+					shouldSet = false;
+					m_Mobile.SendMessage("Bad format");
+				}
+
+				if (shouldSet)
+				{
+					try
+					{
+						CommandLogging.LogChangeProperty(
+							m_Mobile,
+							m_Object,
+							m_Property.Name,
+							toSet == null ? "(null)" : toSet.ToString());
+						m_Property.SetValue(m_Object, toSet, null);
+						PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+					}
+					catch
+					{
+						m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+					}
+				}
+
+				m_Mobile.SendGump(new SetObjectGump(m_Property, m_Mobile, m_Object, m_Stack, m_Type, m_Page, m_List));
+			}
+		}
+	}
+}

Scripts/Gumps/Props/SetObjectTarget.cs

@@ -0,0 +1,69 @@
+#region References
+using System;
+using System.Collections;
+using System.Reflection;
+
+using Server.Commands;
+using Server.Items;
+using Server.Targeting;
+#endregion
+
+namespace Server.Gumps
+{
+	public class SetObjectTarget : Target
+	{
+		private readonly PropertyInfo m_Property;
+		private readonly Mobile m_Mobile;
+		private readonly object m_Object;
+		private readonly Stack m_Stack;
+		private readonly Type m_Type;
+		private readonly int m_Page;
+		private readonly ArrayList m_List;
+
+		public SetObjectTarget(PropertyInfo prop, Mobile mobile, object o, Stack stack, Type type, int page, ArrayList list)
+			: base(-1, false, TargetFlags.None)
+		{
+			m_Property = prop;
+			m_Mobile = mobile;
+			m_Object = o;
+			m_Stack = stack;
+			m_Type = type;
+			m_Page = page;
+			m_List = list;
+		}
+
+		protected override void OnTarget(Mobile from, object targeted)
+		{
+			try
+			{
+				if (m_Type == typeof(Type))
+					targeted = targeted.GetType();
+				else if ((m_Type == typeof(BaseAddon) || m_Type.IsAssignableFrom(typeof(BaseAddon))) && targeted is AddonComponent)
+					targeted = ((AddonComponent)targeted).Addon;
+
+				if (m_Type.IsAssignableFrom(targeted.GetType()))
+				{
+					CommandLogging.LogChangeProperty(m_Mobile, m_Object, m_Property.Name, targeted.ToString());
+					m_Property.SetValue(m_Object, targeted, null);
+					PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+				}
+				else
+				{
+					m_Mobile.SendMessage("That cannot be assigned to a property of type : {0}", m_Type.Name);
+				}
+			}
+			catch
+			{
+				m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+			}
+		}
+
+		protected override void OnTargetFinish(Mobile from)
+		{
+			if (m_Type == typeof(Type))
+				from.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+			else
+				from.SendGump(new SetObjectGump(m_Property, m_Mobile, m_Object, m_Stack, m_Type, m_Page, m_List));
+		}
+	}
+}

Scripts/Gumps/Props/SetPoint2DGump.cs

@@ -0,0 +1,233 @@
+#region References
+using System.Collections;
+using System.Reflection;
+
+using Server.Commands;
+using Server.Network;
+using Server.Targeting;
+#endregion
+
+namespace Server.Gumps
+{
+	public class SetPoint2DGump : Gump
+	{
+		public static readonly bool OldStyle = PropsConfig.OldStyle;
+		public static readonly int GumpOffsetX = PropsConfig.GumpOffsetX;
+		public static readonly int GumpOffsetY = PropsConfig.GumpOffsetY;
+		public static readonly int TextHue = PropsConfig.TextHue;
+		public static readonly int TextOffsetX = PropsConfig.TextOffsetX;
+		public static readonly int OffsetGumpID = PropsConfig.OffsetGumpID;
+		public static readonly int HeaderGumpID = PropsConfig.HeaderGumpID;
+		public static readonly int EntryGumpID = PropsConfig.EntryGumpID;
+		public static readonly int BackGumpID = PropsConfig.BackGumpID;
+		public static readonly int SetGumpID = PropsConfig.SetGumpID;
+		public static readonly int SetWidth = PropsConfig.SetWidth;
+		public static readonly int SetOffsetX = PropsConfig.SetOffsetX, SetOffsetY = PropsConfig.SetOffsetY;
+		public static readonly int SetButtonID1 = PropsConfig.SetButtonID1;
+		public static readonly int SetButtonID2 = PropsConfig.SetButtonID2;
+		public static readonly int PrevWidth = PropsConfig.PrevWidth;
+		public static readonly int PrevOffsetX = PropsConfig.PrevOffsetX, PrevOffsetY = PropsConfig.PrevOffsetY;
+		public static readonly int PrevButtonID1 = PropsConfig.PrevButtonID1;
+		public static readonly int PrevButtonID2 = PropsConfig.PrevButtonID2;
+		public static readonly int NextWidth = PropsConfig.NextWidth;
+		public static readonly int NextOffsetX = PropsConfig.NextOffsetX, NextOffsetY = PropsConfig.NextOffsetY;
+		public static readonly int NextButtonID1 = PropsConfig.NextButtonID1;
+		public static readonly int NextButtonID2 = PropsConfig.NextButtonID2;
+		public static readonly int OffsetSize = PropsConfig.OffsetSize;
+		public static readonly int EntryHeight = PropsConfig.EntryHeight;
+		public static readonly int BorderSize = PropsConfig.BorderSize;
+		private static readonly int CoordWidth = 105;
+		private static readonly int EntryWidth = CoordWidth + OffsetSize + CoordWidth;
+		private static readonly int TotalWidth = OffsetSize + EntryWidth + OffsetSize + SetWidth + OffsetSize;
+		private static readonly int TotalHeight = OffsetSize + (4 * (EntryHeight + OffsetSize));
+		private static readonly int BackWidth = BorderSize + TotalWidth + BorderSize;
+		private static readonly int BackHeight = BorderSize + TotalHeight + BorderSize;
+		private readonly PropertyInfo m_Property;
+		private readonly Mobile m_Mobile;
+		private readonly object m_Object;
+		private readonly Stack m_Stack;
+		private readonly int m_Page;
+		private readonly ArrayList m_List;
+
+		public SetPoint2DGump(PropertyInfo prop, Mobile mobile, object o, Stack stack, int page, ArrayList list)
+			: base(GumpOffsetX, GumpOffsetY)
+		{
+			m_Property = prop;
+			m_Mobile = mobile;
+			m_Object = o;
+			m_Stack = stack;
+			m_Page = page;
+			m_List = list;
+
+			var p = (Point2D)prop.GetValue(o, null);
+
+			AddPage(0);
+
+			AddBackground(0, 0, BackWidth, BackHeight, BackGumpID);
+			AddImageTiled(
+				BorderSize,
+				BorderSize,
+				TotalWidth - (OldStyle ? SetWidth + OffsetSize : 0),
+				TotalHeight,
+				OffsetGumpID);
+
+			var x = BorderSize + OffsetSize;
+			var y = BorderSize + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, prop.Name);
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+			x = BorderSize + OffsetSize;
+			y += EntryHeight + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, "Use your location");
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+			AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 1, GumpButtonType.Reply, 0);
+
+			x = BorderSize + OffsetSize;
+			y += EntryHeight + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, "Target a location");
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+			AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 2, GumpButtonType.Reply, 0);
+
+			x = BorderSize + OffsetSize;
+			y += EntryHeight + OffsetSize;
+
+			AddImageTiled(x, y, CoordWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, CoordWidth - TextOffsetX, EntryHeight, TextHue, "X:");
+			AddTextEntry(x + 16, y, CoordWidth - 16, EntryHeight, TextHue, 0, p.X.ToString());
+			x += CoordWidth + OffsetSize;
+
+			AddImageTiled(x, y, CoordWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, CoordWidth - TextOffsetX, EntryHeight, TextHue, "Y:");
+			AddTextEntry(x + 16, y, CoordWidth - 16, EntryHeight, TextHue, 1, p.Y.ToString());
+			x += CoordWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+			AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 3, GumpButtonType.Reply, 0);
+		}
+
+		public override void OnResponse(NetState sender, RelayInfo info)
+		{
+			Point2D toSet;
+			bool shouldSet, shouldSend;
+
+			switch (info.ButtonID)
+			{
+				case 1: // Current location
+				{
+					toSet = new Point2D(m_Mobile.Location);
+					shouldSet = true;
+					shouldSend = true;
+
+					break;
+				}
+				case 2: // Pick location
+				{
+					m_Mobile.Target = new InternalTarget(m_Property, m_Mobile, m_Object, m_Stack, m_Page, m_List);
+
+					toSet = Point2D.Zero;
+					shouldSet = false;
+					shouldSend = false;
+
+					break;
+				}
+				case 3: // Use values
+				{
+					var x = info.GetTextEntry(0);
+					var y = info.GetTextEntry(1);
+
+					toSet = new Point2D(x == null ? 0 : Utility.ToInt32(x.Text), y == null ? 0 : Utility.ToInt32(y.Text));
+					shouldSet = true;
+					shouldSend = true;
+
+					break;
+				}
+				default:
+				{
+					toSet = Point2D.Zero;
+					shouldSet = false;
+					shouldSend = true;
+
+					break;
+				}
+			}
+
+			if (shouldSet)
+			{
+				try
+				{
+					CommandLogging.LogChangeProperty(m_Mobile, m_Object, m_Property.Name, toSet.ToString());
+					m_Property.SetValue(m_Object, toSet, null);
+					PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+				}
+				catch
+				{
+					m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+				}
+			}
+
+			if (shouldSend)
+				m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+		}
+
+		private class InternalTarget : Target
+		{
+			private readonly PropertyInfo m_Property;
+			private readonly Mobile m_Mobile;
+			private readonly object m_Object;
+			private readonly Stack m_Stack;
+			private readonly int m_Page;
+			private readonly ArrayList m_List;
+
+			public InternalTarget(PropertyInfo prop, Mobile mobile, object o, Stack stack, int page, ArrayList list)
+				: base(-1, true, TargetFlags.None)
+			{
+				m_Property = prop;
+				m_Mobile = mobile;
+				m_Object = o;
+				m_Stack = stack;
+				m_Page = page;
+				m_List = list;
+			}
+
+			protected override void OnTarget(Mobile from, object targeted)
+			{
+				var p = targeted as IPoint3D;
+
+				if (p != null)
+				{
+					try
+					{
+						CommandLogging.LogChangeProperty(m_Mobile, m_Object, m_Property.Name, new Point2D(p).ToString());
+						m_Property.SetValue(m_Object, new Point2D(p), null);
+						PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+					}
+					catch
+					{
+						m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+					}
+				}
+			}
+
+			protected override void OnTargetFinish(Mobile from)
+			{
+				m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+			}
+		}
+	}
+}

Scripts/Gumps/Props/SetPoint3DGump.cs

@@ -0,0 +1,242 @@
+#region References
+using System.Collections;
+using System.Reflection;
+
+using Server.Commands;
+using Server.Network;
+using Server.Targeting;
+#endregion
+
+namespace Server.Gumps
+{
+	public class SetPoint3DGump : Gump
+	{
+		public static readonly bool OldStyle = PropsConfig.OldStyle;
+		public static readonly int GumpOffsetX = PropsConfig.GumpOffsetX;
+		public static readonly int GumpOffsetY = PropsConfig.GumpOffsetY;
+		public static readonly int TextHue = PropsConfig.TextHue;
+		public static readonly int TextOffsetX = PropsConfig.TextOffsetX;
+		public static readonly int OffsetGumpID = PropsConfig.OffsetGumpID;
+		public static readonly int HeaderGumpID = PropsConfig.HeaderGumpID;
+		public static readonly int EntryGumpID = PropsConfig.EntryGumpID;
+		public static readonly int BackGumpID = PropsConfig.BackGumpID;
+		public static readonly int SetGumpID = PropsConfig.SetGumpID;
+		public static readonly int SetWidth = PropsConfig.SetWidth;
+		public static readonly int SetOffsetX = PropsConfig.SetOffsetX, SetOffsetY = PropsConfig.SetOffsetY;
+		public static readonly int SetButtonID1 = PropsConfig.SetButtonID1;
+		public static readonly int SetButtonID2 = PropsConfig.SetButtonID2;
+		public static readonly int PrevWidth = PropsConfig.PrevWidth;
+		public static readonly int PrevOffsetX = PropsConfig.PrevOffsetX, PrevOffsetY = PropsConfig.PrevOffsetY;
+		public static readonly int PrevButtonID1 = PropsConfig.PrevButtonID1;
+		public static readonly int PrevButtonID2 = PropsConfig.PrevButtonID2;
+		public static readonly int NextWidth = PropsConfig.NextWidth;
+		public static readonly int NextOffsetX = PropsConfig.NextOffsetX, NextOffsetY = PropsConfig.NextOffsetY;
+		public static readonly int NextButtonID1 = PropsConfig.NextButtonID1;
+		public static readonly int NextButtonID2 = PropsConfig.NextButtonID2;
+		public static readonly int OffsetSize = PropsConfig.OffsetSize;
+		public static readonly int EntryHeight = PropsConfig.EntryHeight;
+		public static readonly int BorderSize = PropsConfig.BorderSize;
+		private static readonly int CoordWidth = 70;
+		private static readonly int EntryWidth = CoordWidth + OffsetSize + CoordWidth + OffsetSize + CoordWidth;
+		private static readonly int TotalWidth = OffsetSize + EntryWidth + OffsetSize + SetWidth + OffsetSize;
+		private static readonly int TotalHeight = OffsetSize + (4 * (EntryHeight + OffsetSize));
+		private static readonly int BackWidth = BorderSize + TotalWidth + BorderSize;
+		private static readonly int BackHeight = BorderSize + TotalHeight + BorderSize;
+		private readonly PropertyInfo m_Property;
+		private readonly Mobile m_Mobile;
+		private readonly object m_Object;
+		private readonly Stack m_Stack;
+		private readonly int m_Page;
+		private readonly ArrayList m_List;
+
+		public SetPoint3DGump(PropertyInfo prop, Mobile mobile, object o, Stack stack, int page, ArrayList list)
+			: base(GumpOffsetX, GumpOffsetY)
+		{
+			m_Property = prop;
+			m_Mobile = mobile;
+			m_Object = o;
+			m_Stack = stack;
+			m_Page = page;
+			m_List = list;
+
+			var p = (Point3D)prop.GetValue(o, null);
+
+			AddPage(0);
+
+			AddBackground(0, 0, BackWidth, BackHeight, BackGumpID);
+			AddImageTiled(
+				BorderSize,
+				BorderSize,
+				TotalWidth - (OldStyle ? SetWidth + OffsetSize : 0),
+				TotalHeight,
+				OffsetGumpID);
+
+			var x = BorderSize + OffsetSize;
+			var y = BorderSize + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, prop.Name);
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+			x = BorderSize + OffsetSize;
+			y += EntryHeight + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, "Use your location");
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+			AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 1, GumpButtonType.Reply, 0);
+
+			x = BorderSize + OffsetSize;
+			y += EntryHeight + OffsetSize;
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, "Target a location");
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+			AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 2, GumpButtonType.Reply, 0);
+
+			x = BorderSize + OffsetSize;
+			y += EntryHeight + OffsetSize;
+
+			AddImageTiled(x, y, CoordWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, CoordWidth - TextOffsetX, EntryHeight, TextHue, "X:");
+			AddTextEntry(x + 16, y, CoordWidth - 16, EntryHeight, TextHue, 0, p.X.ToString());
+			x += CoordWidth + OffsetSize;
+
+			AddImageTiled(x, y, CoordWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, CoordWidth - TextOffsetX, EntryHeight, TextHue, "Y:");
+			AddTextEntry(x + 16, y, CoordWidth - 16, EntryHeight, TextHue, 1, p.Y.ToString());
+			x += CoordWidth + OffsetSize;
+
+			AddImageTiled(x, y, CoordWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, CoordWidth - TextOffsetX, EntryHeight, TextHue, "Z:");
+			AddTextEntry(x + 16, y, CoordWidth - 16, EntryHeight, TextHue, 2, p.Z.ToString());
+			x += CoordWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+			AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, 3, GumpButtonType.Reply, 0);
+		}
+
+		public override void OnResponse(NetState sender, RelayInfo info)
+		{
+			Point3D toSet;
+			bool shouldSet, shouldSend;
+
+			switch (info.ButtonID)
+			{
+				case 1: // Current location
+				{
+					toSet = m_Mobile.Location;
+					shouldSet = true;
+					shouldSend = true;
+
+					break;
+				}
+				case 2: // Pick location
+				{
+					m_Mobile.Target = new InternalTarget(m_Property, m_Mobile, m_Object, m_Stack, m_Page, m_List);
+
+					toSet = Point3D.Zero;
+					shouldSet = false;
+					shouldSend = false;
+
+					break;
+				}
+				case 3: // Use values
+				{
+					var x = info.GetTextEntry(0);
+					var y = info.GetTextEntry(1);
+					var z = info.GetTextEntry(2);
+
+					toSet = new Point3D(
+						x == null ? 0 : Utility.ToInt32(x.Text),
+						y == null ? 0 : Utility.ToInt32(y.Text),
+						z == null ? 0 : Utility.ToInt32(z.Text));
+					shouldSet = true;
+					shouldSend = true;
+
+					break;
+				}
+				default:
+				{
+					toSet = Point3D.Zero;
+					shouldSet = false;
+					shouldSend = true;
+
+					break;
+				}
+			}
+
+			if (shouldSet)
+			{
+				try
+				{
+					CommandLogging.LogChangeProperty(m_Mobile, m_Object, m_Property.Name, toSet.ToString());
+					m_Property.SetValue(m_Object, toSet, null);
+					PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+				}
+				catch
+				{
+					m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+				}
+			}
+
+			if (shouldSend)
+				m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+		}
+
+		private class InternalTarget : Target
+		{
+			private readonly PropertyInfo m_Property;
+			private readonly Mobile m_Mobile;
+			private readonly object m_Object;
+			private readonly Stack m_Stack;
+			private readonly int m_Page;
+			private readonly ArrayList m_List;
+
+			public InternalTarget(PropertyInfo prop, Mobile mobile, object o, Stack stack, int page, ArrayList list)
+				: base(-1, true, TargetFlags.None)
+			{
+				m_Property = prop;
+				m_Mobile = mobile;
+				m_Object = o;
+				m_Stack = stack;
+				m_Page = page;
+				m_List = list;
+			}
+
+			protected override void OnTarget(Mobile from, object targeted)
+			{
+				var p = targeted as IPoint3D;
+
+				if (p != null)
+				{
+					try
+					{
+						CommandLogging.LogChangeProperty(m_Mobile, m_Object, m_Property.Name, new Point3D(p).ToString());
+						m_Property.SetValue(m_Object, new Point3D(p), null);
+						PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+					}
+					catch
+					{
+						m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+					}
+				}
+			}
+
+			protected override void OnTargetFinish(Mobile from)
+			{
+				m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+			}
+		}
+	}
+}

Scripts/Gumps/Props/SetTimeSpanGump.cs

@@ -0,0 +1,231 @@
+#region References
+using System;
+using System.Collections;
+using System.Reflection;
+
+using Server.Commands;
+using Server.Network;
+#endregion
+
+namespace Server.Gumps
+{
+	public class SetTimeSpanGump : Gump
+	{
+		public static readonly bool OldStyle = PropsConfig.OldStyle;
+		public static readonly int GumpOffsetX = PropsConfig.GumpOffsetX;
+		public static readonly int GumpOffsetY = PropsConfig.GumpOffsetY;
+		public static readonly int TextHue = PropsConfig.TextHue;
+		public static readonly int TextOffsetX = PropsConfig.TextOffsetX;
+		public static readonly int OffsetGumpID = PropsConfig.OffsetGumpID;
+		public static readonly int HeaderGumpID = PropsConfig.HeaderGumpID;
+		public static readonly int EntryGumpID = PropsConfig.EntryGumpID;
+		public static readonly int BackGumpID = PropsConfig.BackGumpID;
+		public static readonly int SetGumpID = PropsConfig.SetGumpID;
+		public static readonly int SetWidth = PropsConfig.SetWidth;
+		public static readonly int SetOffsetX = PropsConfig.SetOffsetX, SetOffsetY = PropsConfig.SetOffsetY;
+		public static readonly int SetButtonID1 = PropsConfig.SetButtonID1;
+		public static readonly int SetButtonID2 = PropsConfig.SetButtonID2;
+		public static readonly int PrevWidth = PropsConfig.PrevWidth;
+		public static readonly int PrevOffsetX = PropsConfig.PrevOffsetX, PrevOffsetY = PropsConfig.PrevOffsetY;
+		public static readonly int PrevButtonID1 = PropsConfig.PrevButtonID1;
+		public static readonly int PrevButtonID2 = PropsConfig.PrevButtonID2;
+		public static readonly int NextWidth = PropsConfig.NextWidth;
+		public static readonly int NextOffsetX = PropsConfig.NextOffsetX, NextOffsetY = PropsConfig.NextOffsetY;
+		public static readonly int NextButtonID1 = PropsConfig.NextButtonID1;
+		public static readonly int NextButtonID2 = PropsConfig.NextButtonID2;
+		public static readonly int OffsetSize = PropsConfig.OffsetSize;
+		public static readonly int EntryHeight = PropsConfig.EntryHeight;
+		public static readonly int BorderSize = PropsConfig.BorderSize;
+		private static readonly int EntryWidth = 212;
+		private static readonly int TotalWidth = OffsetSize + EntryWidth + OffsetSize + SetWidth + OffsetSize;
+		private static readonly int TotalHeight = OffsetSize + (7 * (EntryHeight + OffsetSize));
+		private static readonly int BackWidth = BorderSize + TotalWidth + BorderSize;
+		private static readonly int BackHeight = BorderSize + TotalHeight + BorderSize;
+		private readonly PropertyInfo m_Property;
+		private readonly Mobile m_Mobile;
+		private readonly object m_Object;
+		private readonly Stack m_Stack;
+		private readonly int m_Page;
+		private readonly ArrayList m_List;
+
+		public SetTimeSpanGump(PropertyInfo prop, Mobile mobile, object o, Stack stack, int page, ArrayList list)
+			: base(GumpOffsetX, GumpOffsetY)
+		{
+			m_Property = prop;
+			m_Mobile = mobile;
+			m_Object = o;
+			m_Stack = stack;
+			m_Page = page;
+			m_List = list;
+
+			var ts = (TimeSpan)prop.GetValue(o, null);
+
+			AddPage(0);
+
+			AddBackground(0, 0, BackWidth, BackHeight, BackGumpID);
+			AddImageTiled(
+				BorderSize,
+				BorderSize,
+				TotalWidth - (OldStyle ? SetWidth + OffsetSize : 0),
+				TotalHeight,
+				OffsetGumpID);
+
+			AddRect(0, prop.Name, 0, -1);
+			AddRect(1, ts.ToString(), 0, -1);
+			AddRect(2, "Zero", 1, -1);
+			AddRect(3, "From H:M:S", 2, -1);
+			AddRect(4, "H:", 3, 0);
+			AddRect(5, "M:", 4, 1);
+			AddRect(6, "S:", 5, 2);
+		}
+
+		public override void OnResponse(NetState sender, RelayInfo info)
+		{
+			TimeSpan toSet;
+			bool shouldSet, shouldSend;
+
+			var h = info.GetTextEntry(0);
+			var m = info.GetTextEntry(1);
+			var s = info.GetTextEntry(2);
+
+			switch (info.ButtonID)
+			{
+				case 1: // Zero
+				{
+					toSet = TimeSpan.Zero;
+					shouldSet = true;
+					shouldSend = true;
+
+					break;
+				}
+				case 2: // From H:M:S
+				{
+					var successfulParse = false;
+					if (h != null && m != null && s != null)
+					{
+						successfulParse = TimeSpan.TryParse(h.Text + ":" + m.Text + ":" + s.Text, out toSet);
+					}
+					else
+					{
+						toSet = TimeSpan.Zero;
+					}
+
+					shouldSet = shouldSend = successfulParse;
+
+					break;
+				}
+				case 3: // From H
+				{
+					if (h != null)
+					{
+						try
+						{
+							toSet = TimeSpan.FromHours(Utility.ToDouble(h.Text));
+							shouldSet = true;
+							shouldSend = true;
+
+							break;
+						}
+						catch
+						{ }
+					}
+
+					toSet = TimeSpan.Zero;
+					shouldSet = false;
+					shouldSend = false;
+
+					break;
+				}
+				case 4: // From M
+				{
+					if (m != null)
+					{
+						try
+						{
+							toSet = TimeSpan.FromMinutes(Utility.ToDouble(m.Text));
+							shouldSet = true;
+							shouldSend = true;
+
+							break;
+						}
+						catch
+						{ }
+					}
+
+					toSet = TimeSpan.Zero;
+					shouldSet = false;
+					shouldSend = false;
+
+					break;
+				}
+				case 5: // From S
+				{
+					if (s != null)
+					{
+						try
+						{
+							toSet = TimeSpan.FromSeconds(Utility.ToDouble(s.Text));
+							shouldSet = true;
+							shouldSend = true;
+
+							break;
+						}
+						catch
+						{ }
+					}
+
+					toSet = TimeSpan.Zero;
+					shouldSet = false;
+					shouldSend = false;
+
+					break;
+				}
+				default:
+				{
+					toSet = TimeSpan.Zero;
+					shouldSet = false;
+					shouldSend = true;
+
+					break;
+				}
+			}
+
+			if (shouldSet)
+			{
+				try
+				{
+					CommandLogging.LogChangeProperty(m_Mobile, m_Object, m_Property.Name, toSet.ToString());
+					m_Property.SetValue(m_Object, toSet, null);
+					PropertiesGump.OnValueChanged(m_Object, m_Property, m_Stack);
+				}
+				catch
+				{
+					m_Mobile.SendMessage("An exception was caught. The property may not have changed.");
+				}
+			}
+
+			if (shouldSend)
+				m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
+		}
+
+		private void AddRect(int index, string str, int button, int text)
+		{
+			var x = BorderSize + OffsetSize;
+			var y = BorderSize + OffsetSize + (index * (EntryHeight + OffsetSize));
+
+			AddImageTiled(x, y, EntryWidth, EntryHeight, EntryGumpID);
+			AddLabelCropped(x + TextOffsetX, y, EntryWidth - TextOffsetX, EntryHeight, TextHue, str);
+
+			if (text != -1)
+				AddTextEntry(x + 16 + TextOffsetX, y, EntryWidth - TextOffsetX - 16, EntryHeight, TextHue, text, "");
+
+			x += EntryWidth + OffsetSize;
+
+			if (SetGumpID != 0)
+				AddImageTiled(x, y, SetWidth, EntryHeight, SetGumpID);
+
+			if (button != 0)
+				AddButton(x + SetOffsetX, y + SetOffsetY, SetButtonID1, SetButtonID2, button, GumpButtonType.Reply, 0);
+		}
+	}
+}