Overwrite

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

Scripts/SubSystem/VitaNex/Core/PropertyObjects/ObjectProperty.cs

@@ -0,0 +1,413 @@
+#region Header
+//               _,-'/-'/
+//   .      __,-; ,'( '/
+//    \.    `-.__`-._`:_,-._       _ , . ``
+//     `:-._,------' ` _,`--` -: `_ , ` ,' :
+//        `---..__,,--'  (C) 2023  ` -'. -'
+//        #  Vita-Nex [http://core.vita-nex.com]  #
+//  {o)xxx|===============-   #   -===============|xxx(o}
+//        #                                       #
+#endregion
+
+#region References
+using System;
+using System.Reflection;
+
+using Server;
+#endregion
+
+namespace VitaNex
+{
+	public sealed class ObjectProperty : PropertyObject
+	{
+		[CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
+		public string Name { get; set; }
+
+		public Func<object, object> GetHandler { get; set; }
+		public Action<object, object> SetHandler { get; set; }
+
+		public ObjectProperty()
+			: this(String.Empty)
+		{ }
+
+		public ObjectProperty(string name)
+		{
+			Name = name ?? String.Empty;
+		}
+
+		public ObjectProperty(GenericReader reader)
+			: base(reader)
+		{ }
+
+		public override void Reset()
+		{
+			Name = String.Empty;
+		}
+
+		public override void Clear()
+		{
+			Name = String.Empty;
+		}
+
+		public override string ToString()
+		{
+			return Name;
+		}
+
+		public bool IsSupported(object o, object a)
+		{
+			return IsSupported(o as Type ?? o?.GetType(), a as Type ?? a?.GetType());
+        }
+
+		public bool IsSupported(Type t, Type v)
+		{
+			var p = t?.GetProperty(Name);
+
+			return p != null && (v == null || p.PropertyType == v);
+		}
+
+		public bool IsSupported(object o)
+		{
+			return IsSupported(o, null);
+		}
+
+		public bool IsSupported(Type t)
+		{
+			return IsSupported(t, null);
+		}
+
+        public bool IsSupported<TObj>(object v)
+        {
+            return IsSupported(typeof(TObj), v);
+		}
+
+		public bool IsSupported<TObj>(Type v)
+		{
+			return IsSupported(typeof(TObj), v);
+		}
+
+		public bool IsSupported<TObj>()
+		{
+			return IsSupported(typeof(TObj), null);
+		}
+
+		public bool IsSupported<TObj, TVal>()
+		{
+			return IsSupported(typeof(TObj), typeof(TVal));
+		}
+
+		public T GetValue<T>(object o, T def = default(T))
+		{
+			if (String.IsNullOrWhiteSpace(Name) || o == null)
+			{
+				return def;
+			}
+
+			try
+			{
+				if (GetHandler != null)
+				{
+					return (T)GetHandler(o);
+				}
+			}
+			catch
+			{ }
+
+			try
+			{
+				var t = o as Type ?? o.GetType();
+				var f = o is Type ? BindingFlags.Static : BindingFlags.Instance;
+
+				var p = t.GetProperty(Name, f | BindingFlags.Public);
+
+				return (T)p.GetValue(o is Type ? null : o, null);
+			}
+			catch
+			{
+			}
+			
+			return def;
+		}
+
+		public object GetValue(object o, object def = null)
+		{
+			return GetValue<object>(o, def);
+		}
+
+		public bool SetValue(object o, object val)
+		{
+			if (String.IsNullOrWhiteSpace(Name) || o == null)
+			{
+				return false;
+			}
+
+			try
+			{
+				if (SetHandler != null)
+				{
+					SetHandler(o, val);
+					return true;
+				}
+			}
+			catch
+			{ }
+
+			try
+			{
+				var t = o as Type ?? o.GetType();
+				var f = o is Type ? BindingFlags.Static : BindingFlags.Instance;
+
+				var p = t.GetProperty(Name, f | BindingFlags.Public);
+
+				p.SetValue(o is Type ? null : o, val, null);
+
+				return true;
+			}
+			catch
+			{
+			}
+
+			return false;
+		}
+
+		public bool Add(object o, object val)
+		{
+			if (val is IConvertible)
+			{
+				var cur = GetValue(o);
+
+				if (cur is char c)
+				{
+					return SetValue(o, unchecked(c + Convert.ToChar(val)));
+				}
+
+				if (cur is sbyte b1)
+				{
+					return SetValue(o, unchecked(b1 + Convert.ToSByte(val)));
+				}
+
+				if (cur is byte b2)
+				{
+					return SetValue(o, unchecked(b2 + Convert.ToByte(val)));
+				}
+
+				if (cur is short s1)
+				{
+					return SetValue(o, unchecked(s1 + Convert.ToInt16(val)));
+				}
+
+				if (cur is ushort s2)
+				{
+					return SetValue(o, unchecked(s2 + Convert.ToUInt16(val)));
+				}
+
+				if (cur is int i1)
+				{
+					return SetValue(o, unchecked(i1 + Convert.ToInt32(val)));
+				}
+
+				if (cur is uint i2)
+				{
+					return SetValue(o, unchecked(i2 + Convert.ToUInt32(val)));
+				}
+
+				if (cur is long l1)
+				{
+					return SetValue(o, unchecked(l1 + Convert.ToInt64(val)));
+				}
+
+				if (cur is ulong l2)
+				{
+					return SetValue(o, unchecked(l2 + Convert.ToUInt64(val)));
+				}
+
+				if (cur is float f1)
+				{
+					return SetValue(o, unchecked(f1 + Convert.ToSingle(val)));
+				}
+
+				if (cur is decimal f2)
+				{
+					return SetValue(o, unchecked(f2 + Convert.ToDecimal(val)));
+				}
+
+				if (cur is double f3)
+				{
+					return SetValue(o, unchecked(f3 + Convert.ToDouble(val)));
+				}
+
+				if (cur is Enum e)
+				{
+					return SetValue(o, Enum.ToObject(e.GetType(), unchecked(Convert.ToInt64(e) + Convert.ToInt64(val))));
+				}
+			}
+
+			if (val is TimeSpan ts)
+			{
+				var cur = GetValue(o);
+
+				if (cur is TimeSpan cts)
+				{
+					return SetValue(o, cts + ts);
+				}
+
+				if (cur is DateTime cdt)
+				{
+					return SetValue(o, cdt + ts);
+				}
+			}
+
+			return false;
+		}
+
+		public bool Subtract(object o, object val)
+		{
+			return Subtract(o, val, false);
+		}
+
+		public bool Subtract(object o, object val, bool limit)
+		{
+			if (val is IConvertible)
+			{
+				var cur = GetValue(o);
+
+				if (cur is char c)
+				{
+					return (!limit || c >= Convert.ToChar(val)) && SetValue(o, unchecked(c - Convert.ToChar(val)));
+				}
+
+				if (cur is sbyte b1)
+				{
+					return (!limit || b1 >= Convert.ToSByte(val)) && SetValue(o, unchecked(b1 - Convert.ToSByte(val)));
+				}
+
+				if (cur is byte b2)
+				{
+					return (!limit || b2 >= Convert.ToByte(val)) && SetValue(o, unchecked(b2 - Convert.ToByte(val)));
+				}
+
+				if (cur is short s1)
+				{
+					return (!limit || s1 >= Convert.ToInt16(val)) && SetValue(o, unchecked(s1 - Convert.ToInt16(val)));
+				}
+
+				if (cur is ushort s2)
+				{
+					return (!limit || s2 >= Convert.ToUInt16(val)) && SetValue(o, unchecked(s2 - Convert.ToUInt16(val)));
+				}
+
+				if (cur is int i1)
+				{
+					return (!limit || i1 >= Convert.ToInt32(val)) && SetValue(o, unchecked(i1 - Convert.ToInt32(val)));
+				}
+
+				if (cur is uint i2)
+				{
+					return (!limit || i2 >= Convert.ToUInt32(val)) && SetValue(o, unchecked(i2 - Convert.ToUInt32(val)));
+				}
+
+				if (cur is long l1)
+				{
+					return (!limit || l1 >= Convert.ToInt64(val)) && SetValue(o, unchecked(l1 - Convert.ToInt64(val)));
+				}
+
+				if (cur is ulong l2)
+				{
+					return (!limit || l2 >= Convert.ToUInt64(val)) && SetValue(o, unchecked(l2 - Convert.ToUInt64(val)));
+				}
+
+				if (cur is float f1)
+				{
+					return (!limit || f1 >= Convert.ToSingle(val)) && SetValue(o, unchecked(f1 - Convert.ToSingle(val)));
+				}
+
+				if (cur is decimal f2)
+				{
+					return (!limit || f2 >= Convert.ToDecimal(val)) && SetValue(o, unchecked(f2 - Convert.ToDecimal(val)));
+				}
+
+				if (cur is double f3)
+				{
+					return (!limit || f3 >= Convert.ToDouble(val)) && SetValue(o, unchecked(f3 - Convert.ToDouble(val)));
+				}
+
+				if (cur is Enum e)
+				{
+					return (!limit || Convert.ToInt64(e) >= Convert.ToInt64(val)) && SetValue(o, Enum.ToObject(e.GetType(), unchecked(Convert.ToInt64(e) - Convert.ToInt64(val))));
+				}
+			}
+
+			if (val is TimeSpan ts)
+			{
+				var cur = GetValue(o);
+
+				if (cur is TimeSpan cts)
+				{
+					return (!limit || cts >= ts) && SetValue(o, cts - ts);
+				}
+
+				if (cur is DateTime cdt)
+				{
+					return (!limit || cdt >= DateTime.MinValue + ts) && SetValue(o, cdt - ts);
+				}
+			}
+
+			return false;
+		}
+
+		public bool Consume(object o, object val)
+		{
+			return Subtract(o, val, true);
+		}
+
+		public bool SetDefault(object o)
+		{
+			var cur = GetValue(o);
+
+			if (cur is sbyte || cur is byte || cur is short || cur is ushort || cur is int || cur is uint || cur is long || cur is ulong || cur is float || cur is decimal || cur is double || cur is Enum)
+			{
+				return SetValue(o, 0);
+			}
+
+			if (cur is TimeSpan)
+			{
+				return SetValue(o, TimeSpan.Zero);
+			}
+
+			if (cur is DateTime)
+			{
+				return SetValue(o, DateTime.MinValue);
+			}
+
+			if (cur is char)
+			{
+				return SetValue(o, ' ');
+			}
+
+			if (cur is string)
+			{
+				return SetValue(o, String.Empty);
+			}
+
+			return SetValue(o, null);
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.SetVersion(0);
+
+			writer.Write(Name);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.GetVersion();
+
+			Name = reader.ReadString();
+		}
+	}
+}

Scripts/SubSystem/VitaNex/Core/PropertyObjects/PropertyObject.cs

@@ -0,0 +1,90 @@
+#region Header
+//               _,-'/-'/
+//   .      __,-; ,'( '/
+//    \.    `-.__`-._`:_,-._       _ , . ``
+//     `:-._,------' ` _,`--` -: `_ , ` ,' :
+//        `---..__,,--'  (C) 2023  ` -'. -'
+//        #  Vita-Nex [http://core.vita-nex.com]  #
+//  {o)xxx|===============-   #   -===============|xxx(o}
+//        #                                       #
+#endregion
+
+#region References
+using Server;
+#endregion
+
+namespace VitaNex
+{
+	[PropertyObject]
+	public abstract class PropertyObject : IHued
+	{
+		int IHued.HuedItemID => 2278;
+
+		[CommandProperty(AccessLevel.Administrator)]
+		public virtual bool InvokeClear
+		{
+			get => true;
+			set
+			{
+				if (value)
+				{
+					Clear();
+				}
+			}
+		}
+
+		[CommandProperty(AccessLevel.Administrator)]
+		public virtual bool InvokeReset
+		{
+			get => true;
+			set
+			{
+				if (value)
+				{
+					Reset();
+				}
+			}
+		}
+
+		public PropertyObject()
+		{ }
+
+		public PropertyObject(GenericReader reader)
+			: this(reader, false)
+		{ }
+
+		public PropertyObject(GenericReader reader, bool deferred)
+			: this()
+		{
+			if (deferred)
+			{
+				Timer.DelayCall(Deserialize, reader);
+			}
+			else
+			{
+				Deserialize(reader);
+			}
+		}
+
+		public virtual void Clear()
+		{ }
+
+		public virtual void Reset()
+		{ }
+
+		public virtual void Serialize(GenericWriter writer)
+		{
+			writer.SetVersion(0);
+		}
+
+		public virtual void Deserialize(GenericReader reader)
+		{
+			reader.GetVersion();
+		}
+
+		public override string ToString()
+		{
+			return "...";
+		}
+	}
+}

Scripts/SubSystem/VitaNex/Core/PropertyObjects/SettingsObject.cs

@@ -0,0 +1,188 @@
+#region Header
+//               _,-'/-'/
+//   .      __,-; ,'( '/
+//    \.    `-.__`-._`:_,-._       _ , . ``
+//     `:-._,------' ` _,`--` -: `_ , ` ,' :
+//        `---..__,,--'  (C) 2023  ` -'. -'
+//        #  Vita-Nex [http://core.vita-nex.com]  #
+//  {o)xxx|===============-   #   -===============|xxx(o}
+//        #                                       #
+#endregion
+
+#region References
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+using Server;
+#endregion
+
+namespace VitaNex
+{
+	public abstract class SettingsObject<TFlags> : PropertyObject, IEnumerable<TFlags> where TFlags : struct, Enum
+	{
+		private static readonly Type _FlagsType = typeof(TFlags);
+
+		public static readonly TFlags[] AllFlags = Enum.GetValues(_FlagsType).CastToArray<TFlags>();
+
+		private TFlags _Flags;
+
+		[CommandProperty(AccessLevel.Administrator)]
+		public virtual TFlags Flags
+		{
+			get => _Flags;
+			set
+			{
+				if (Equals(_Flags, value))
+				{
+					return;
+				}
+
+				var old = _Flags;
+
+				_Flags = value;
+
+				OnFlagsChanged(old);
+			}
+		}
+
+		public virtual TFlags DefaultFlags => default(TFlags);
+
+		public virtual bool this[TFlags f] { get => GetFlag(f); set => SetFlag(f, value); }
+
+		public virtual bool this[int index] { get => this[AllFlags[index]]; set => this[AllFlags[index]] = value; }
+
+		public int Length => AllFlags.Length;
+
+		public Action<TFlags, bool> OnChanged { get; set; }
+
+		public SettingsObject()
+		{
+			_Flags = DefaultFlags;
+		}
+
+		public SettingsObject(TFlags flags)
+		{
+			_Flags = flags;
+		}
+
+		public SettingsObject(GenericReader reader)
+			: base(reader)
+		{ }
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return AllFlags.GetEnumerator();
+		}
+
+		IEnumerator<TFlags> IEnumerable<TFlags>.GetEnumerator()
+		{
+			return AllFlags.GetEnumerator<TFlags>();
+		}
+
+		public override void Clear()
+		{
+			_Flags = DefaultFlags;
+		}
+
+		public override void Reset()
+		{
+			_Flags = DefaultFlags;
+		}
+
+		protected virtual void OnFlagsChanged(TFlags old)
+		{ }
+
+		public void SetFlag(TFlags flag, bool value)
+		{
+			var t = Enum.GetUnderlyingType(_FlagsType);
+
+			if (t.Name.StartsWith("U", StringComparison.OrdinalIgnoreCase))
+			{
+				var ul = Convert.ToUInt64(Enum.ToObject(_FlagsType, Flags));
+				var ur = Convert.ToUInt64(Enum.ToObject(_FlagsType, flag));
+
+				if (value)
+				{
+					flag = (TFlags)Enum.ToObject(_FlagsType, ul | ur);
+				}
+				else
+				{
+					flag = (TFlags)Enum.ToObject(_FlagsType, ul & ~ur);
+				}
+			}
+			else
+			{
+				var l = Convert.ToInt64(Enum.ToObject(_FlagsType, Flags));
+				var r = Convert.ToInt64(Enum.ToObject(_FlagsType, flag));
+
+				if (value)
+				{
+					flag = (TFlags)Enum.ToObject(_FlagsType, l | r);
+				}
+				else
+				{
+					flag = (TFlags)Enum.ToObject(_FlagsType, l & ~r);
+				}
+			}
+
+			Flags = flag;
+
+			if (OnChanged != null)
+			{
+				OnChanged(flag, value);
+			}
+		}
+
+		public bool GetFlag(TFlags flag)
+		{
+			var t = Enum.GetUnderlyingType(_FlagsType);
+
+			if (t.Name.StartsWith("U", StringComparison.OrdinalIgnoreCase))
+			{
+				var ul = Convert.ToUInt64(Enum.ToObject(_FlagsType, Flags));
+				var ur = Convert.ToUInt64(Enum.ToObject(_FlagsType, flag));
+
+				if (ur == 0UL || ur == ~0UL)
+				{
+					return ul == ur;
+				}
+
+				return (ul & ur) != 0;
+			}
+
+			var l = Convert.ToInt64(Enum.ToObject(_FlagsType, Flags));
+			var r = Convert.ToInt64(Enum.ToObject(_FlagsType, flag));
+
+			if (r == 0L || r == ~0L)
+			{
+				return l == r;
+			}
+
+			return (l & r) != 0;
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.SetVersion(0);
+
+			writer.WriteFlag(_Flags);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.GetVersion();
+
+			_Flags = reader.ReadFlag<TFlags>();
+		}
+
+		public static implicit operator TFlags(SettingsObject<TFlags> o)
+		{
+			return o.Flags;
+		}
+	}
+}

Scripts/SubSystem/VitaNex/Core/PropertyObjects/TypeSelect.cs

@@ -0,0 +1,524 @@
+#region Header
+//               _,-'/-'/
+//   .      __,-; ,'( '/
+//    \.    `-.__`-._`:_,-._       _ , . ``
+//     `:-._,------' ` _,`--` -: `_ , ` ,' :
+//        `---..__,,--'  (C) 2023  ` -'. -'
+//        #  Vita-Nex [http://core.vita-nex.com]  #
+//  {o)xxx|===============-   #   -===============|xxx(o}
+//        #                                       #
+#endregion
+
+#region References
+using System;
+
+using Server;
+using Server.Mobiles;
+#endregion
+
+namespace VitaNex
+{
+	public interface ITypeSelectProperty
+	{
+		Type ExpectedType { get; }
+		Type InternalType { get; }
+
+		bool IsNotNull { get; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		string TypeName { get; set; }
+
+		bool CheckType(Type t);
+
+		object CreateInstanceObject(params object[] args);
+	}
+
+	public interface ITypeSelectProperty<TObj> : ITypeSelectProperty
+		where TObj : class
+	{
+		TObj CreateInstance(params object[] args);
+
+		T CreateInstance<T>(params object[] args)
+			where T : TObj;
+	}
+
+	public class TypeSelectProperty<TObj> : PropertyObject, ITypeSelectProperty<TObj>
+		where TObj : class
+	{
+		private readonly Type _ExpectedType = typeof(TObj);
+
+		public Type ExpectedType => _ExpectedType;
+
+		public Type InternalType { get; protected set; }
+
+		public bool IsNotNull => InternalType != null;
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public virtual string TypeName
+		{
+			get => IsNotNull ? InternalType.Name : String.Empty;
+			set
+			{
+				if (String.IsNullOrWhiteSpace(value))
+				{
+					InternalType = null;
+					return;
+				}
+
+				VitaNexCore.TryCatch(
+					() =>
+					{
+						var t = Type.GetType(value, false, true) ??
+								ScriptCompiler.FindTypeByName(value, true) ?? ScriptCompiler.FindTypeByFullName(value, true);
+
+						if (CheckType(t))
+						{
+							InternalType = t;
+						}
+					},
+					VitaNexCore.ToConsole);
+			}
+		}
+
+		public TypeSelectProperty(string type = "")
+		{
+			TypeName = type;
+		}
+
+		public TypeSelectProperty(GenericReader reader)
+			: base(reader)
+		{ }
+
+		public override void Clear()
+		{
+			TypeName = null;
+		}
+
+		public override void Reset()
+		{
+			TypeName = null;
+		}
+
+		public virtual bool CheckType(Type t)
+		{
+			return CheckType(t, true);
+		}
+
+		public virtual bool CheckType(Type t, bool children)
+		{
+			return t != null &&
+				   (!children || ExpectedType.IsSealed ? t.IsEqual(ExpectedType) : t.IsEqualOrChildOf(ExpectedType));
+		}
+
+		public virtual object CreateInstanceObject(params object[] args)
+		{
+			return CreateInstance(args);
+		}
+
+		public virtual TObj CreateInstance(params object[] args)
+		{
+			return CreateInstance<TObj>(args);
+		}
+
+		public virtual T CreateInstance<T>(params object[] args)
+			where T : TObj
+		{
+			return IsNotNull ? InternalType.CreateInstanceSafe<T>(args) : default(T);
+		}
+
+		public override string ToString()
+		{
+			return String.IsNullOrEmpty(TypeName) ? "null" : TypeName;
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			var version = writer.SetVersion(0);
+
+			switch (version)
+			{
+				case 0:
+					writer.WriteType(InternalType);
+					break;
+			}
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 0:
+					InternalType = reader.ReadType();
+					break;
+			}
+		}
+
+		public static implicit operator TypeSelectProperty<TObj>(string typeName)
+		{
+			return new TypeSelectProperty<TObj>(typeName);
+		}
+
+		public static implicit operator string(TypeSelectProperty<TObj> t)
+		{
+			return ((t == null || t.InternalType == null) ? String.Empty : t.InternalType.FullName);
+		}
+
+		public static implicit operator TypeSelectProperty<TObj>(Type t)
+		{
+			return new TypeSelectProperty<TObj>((t == null) ? null : t.FullName);
+		}
+
+		public static implicit operator Type(TypeSelectProperty<TObj> t)
+		{
+			return ((t == null) ? null : t.InternalType);
+		}
+	}
+
+	public class EntityTypeSelectProperty : TypeSelectProperty<IEntity>
+	{
+		public EntityTypeSelectProperty(string type = "")
+			: base(type)
+		{ }
+
+		public EntityTypeSelectProperty(GenericReader reader)
+			: base(reader)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			var version = writer.SetVersion(0);
+
+			switch (version)
+			{
+				case 0:
+					break;
+			}
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 0:
+					break;
+			}
+		}
+
+		public static implicit operator EntityTypeSelectProperty(string typeName)
+		{
+			return new EntityTypeSelectProperty(typeName);
+		}
+
+		public static implicit operator string(EntityTypeSelectProperty t)
+		{
+			return ((t == null || t.InternalType == null) ? String.Empty : t.InternalType.FullName);
+		}
+
+		public static implicit operator EntityTypeSelectProperty(Type t)
+		{
+			return new EntityTypeSelectProperty((t == null) ? null : t.FullName);
+		}
+
+		public static implicit operator Type(EntityTypeSelectProperty t)
+		{
+			return ((t == null) ? null : t.InternalType);
+		}
+	}
+
+	public class ItemTypeSelectProperty : TypeSelectProperty<Item>
+	{
+		public ItemTypeSelectProperty(string type = "")
+			: base(type)
+		{ }
+
+		public ItemTypeSelectProperty(GenericReader reader)
+			: base(reader)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			var version = writer.SetVersion(0);
+
+			switch (version)
+			{
+				case 0:
+					break;
+			}
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 0:
+					break;
+			}
+		}
+
+		public static implicit operator ItemTypeSelectProperty(string typeName)
+		{
+			return new ItemTypeSelectProperty(typeName);
+		}
+
+		public static implicit operator string(ItemTypeSelectProperty t)
+		{
+			return ((t == null || t.InternalType == null) ? String.Empty : t.InternalType.FullName);
+		}
+
+		public static implicit operator ItemTypeSelectProperty(Type t)
+		{
+			return new ItemTypeSelectProperty((t == null) ? null : t.FullName);
+		}
+
+		public static implicit operator Type(ItemTypeSelectProperty t)
+		{
+			return ((t == null) ? null : t.InternalType);
+		}
+	}
+
+	public class MobileTypeSelectProperty : TypeSelectProperty<Mobile>
+	{
+		public MobileTypeSelectProperty(string type = "")
+			: base(type)
+		{ }
+
+		public MobileTypeSelectProperty(GenericReader reader)
+			: base(reader)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			var version = writer.SetVersion(0);
+
+			switch (version)
+			{
+				case 0:
+					break;
+			}
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 0:
+					break;
+			}
+		}
+
+		public static implicit operator MobileTypeSelectProperty(string typeName)
+		{
+			return new MobileTypeSelectProperty(typeName);
+		}
+
+		public static implicit operator string(MobileTypeSelectProperty t)
+		{
+			return ((t == null || t.InternalType == null) ? String.Empty : t.InternalType.FullName);
+		}
+
+		public static implicit operator MobileTypeSelectProperty(Type t)
+		{
+			return new MobileTypeSelectProperty((t == null) ? null : t.FullName);
+		}
+
+		public static implicit operator Type(MobileTypeSelectProperty t)
+		{
+			return ((t == null) ? null : t.InternalType);
+		}
+	}
+
+	public class CreatureTypeSelectProperty : TypeSelectProperty<BaseCreature>
+	{
+		public CreatureTypeSelectProperty(string type = "")
+			: base(type)
+		{ }
+
+		public CreatureTypeSelectProperty(GenericReader reader)
+			: base(reader)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			var version = writer.SetVersion(0);
+
+			switch (version)
+			{
+				case 0:
+					break;
+			}
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 0:
+					break;
+			}
+		}
+
+		public static implicit operator CreatureTypeSelectProperty(string typeName)
+		{
+			return new CreatureTypeSelectProperty(typeName);
+		}
+
+		public static implicit operator string(CreatureTypeSelectProperty t)
+		{
+			return ((t == null || t.InternalType == null) ? String.Empty : t.InternalType.FullName);
+		}
+
+		public static implicit operator CreatureTypeSelectProperty(Type t)
+		{
+			return new CreatureTypeSelectProperty((t == null) ? null : t.FullName);
+		}
+
+		public static implicit operator Type(CreatureTypeSelectProperty t)
+		{
+			return ((t == null) ? null : t.InternalType);
+		}
+	}
+
+	public class VendorTypeSelectProperty : TypeSelectProperty<BaseVendor>
+	{
+		public VendorTypeSelectProperty(string type = "")
+			: base(type)
+		{ }
+
+		public VendorTypeSelectProperty(GenericReader reader)
+			: base(reader)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			var version = writer.SetVersion(0);
+
+			switch (version)
+			{
+				case 0:
+					break;
+			}
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 0:
+					break;
+			}
+		}
+
+		public static implicit operator VendorTypeSelectProperty(string typeName)
+		{
+			return new VendorTypeSelectProperty(typeName);
+		}
+
+		public static implicit operator string(VendorTypeSelectProperty t)
+		{
+			return ((t == null || t.InternalType == null) ? String.Empty : t.InternalType.FullName);
+		}
+
+		public static implicit operator VendorTypeSelectProperty(Type t)
+		{
+			return new VendorTypeSelectProperty((t == null) ? null : t.FullName);
+		}
+
+		public static implicit operator Type(VendorTypeSelectProperty t)
+		{
+			return ((t == null) ? null : t.InternalType);
+		}
+	}
+
+	public class SpellTypeSelectProperty : TypeSelectProperty<ISpell>
+	{
+		public SpellTypeSelectProperty(string type = "")
+			: base(type)
+		{ }
+
+		public SpellTypeSelectProperty(GenericReader reader)
+			: base(reader)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			var version = writer.SetVersion(0);
+
+			switch (version)
+			{
+				case 0:
+					break;
+			}
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 0:
+					break;
+			}
+		}
+
+		public static implicit operator SpellTypeSelectProperty(string typeName)
+		{
+			return new SpellTypeSelectProperty(typeName);
+		}
+
+		public static implicit operator string(SpellTypeSelectProperty t)
+		{
+			return ((t == null || t.InternalType == null) ? String.Empty : t.InternalType.FullName);
+		}
+
+		public static implicit operator SpellTypeSelectProperty(Type t)
+		{
+			return new SpellTypeSelectProperty((t == null) ? null : t.FullName);
+		}
+
+		public static implicit operator Type(SpellTypeSelectProperty t)
+		{
+			return ((t == null) ? null : t.InternalType);
+		}
+	}
+}