Overwrite

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

Scripts/SubSystem/VitaNex/Core/Items/Utility/AccessCloak.cs

@@ -0,0 +1,194 @@
+#region Header
+//               _,-'/-'/
+//   .      __,-; ,'( '/
+//    \.    `-.__`-._`:_,-._       _ , . ``
+//     `:-._,------' ` _,`--` -: `_ , ` ,' :
+//        `---..__,,--'  (C) 2023  ` -'. -'
+//        #  Vita-Nex [http://core.vita-nex.com]  #
+//  {o)xxx|===============-   #   -===============|xxx(o}
+//        #                                       #
+#endregion
+
+#region References
+using System;
+using System.Drawing;
+
+using Server;
+using Server.Items;
+#endregion
+
+namespace VitaNex.Items
+{
+	public class AccessCloak : BaseCloak
+	{
+		private AccessLevel _AccessTemp;
+		private AccessLevel _AccessMask;
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public AccessLevel AccessMask
+		{
+			get => _AccessMask;
+			set
+			{
+				if (value <= _AccessTemp)
+				{
+					_AccessMask = value;
+				}
+			}
+		}
+
+		public override bool DisplayLootType => false;
+		public override bool DisplayWeight => false;
+
+		[Constructable]
+		public AccessCloak()
+			: this(AccessLevel.Player)
+		{ }
+
+		public AccessCloak(Mobile owner)
+			: this(owner, AccessLevel.Player)
+		{ }
+
+		public AccessCloak(Mobile owner, AccessLevel mask)
+			: this(mask)
+		{
+			_AccessTemp = owner != null ? owner.AccessLevel : AccessLevel.Player;
+		}
+
+		public AccessCloak(AccessLevel mask)
+			: base(0x1515)
+		{
+			_AccessMask = mask;
+
+			Name = "Access Cloak";
+			Hue = Utility.RandomDyedHue();
+			LootType = LootType.Blessed;
+			StrRequirement = 0;
+			Weight = 0;
+		}
+
+		public AccessCloak(Serial serial)
+			: base(serial)
+		{ }
+
+		public override DeathMoveResult OnParentDeath(Mobile parent)
+		{
+			return DeathMoveResult.MoveToBackpack;
+		}
+
+		public override bool OnEquip(Mobile from)
+		{
+			if (BlessedFor == null)
+			{
+				BlessedFor = from;
+				_AccessTemp = BlessedFor.AccessLevel;
+			}
+
+			if (BlessedFor != from)
+			{
+				from.SendMessage("That does not belong to you.");
+				return false;
+			}
+
+			return base.OnEquip(from);
+		}
+
+#if NEWPARENT
+		public override void OnAdded(IEntity parent)
+#else
+		public override void OnAdded(object parent)
+#endif
+		{
+			if (BlessedFor != null)
+			{
+				BlessedFor.AccessLevel = _AccessMask;
+
+				BlessedFor.Hits = BlessedFor.HitsMax;
+				BlessedFor.Stam = BlessedFor.StamMax;
+				BlessedFor.Mana = BlessedFor.ManaMax;
+			}
+
+			base.OnAdded(parent);
+		}
+
+#if NEWPARENT
+		public override void OnRemoved(IEntity parent)
+#else
+		public override void OnRemoved(object parent)
+#endif
+		{
+			if (BlessedFor != null)
+			{
+				BlessedFor.AccessLevel = _AccessTemp;
+
+				BlessedFor.Hits = BlessedFor.HitsMax;
+				BlessedFor.Stam = BlessedFor.StamMax;
+				BlessedFor.Mana = BlessedFor.ManaMax;
+			}
+
+			base.OnRemoved(parent);
+		}
+
+		public override void OnDelete()
+		{
+			if (BlessedFor != null)
+			{
+				BlessedFor.AccessLevel = _AccessTemp;
+
+				BlessedFor.Hits = BlessedFor.HitsMax;
+				BlessedFor.Stam = BlessedFor.StamMax;
+				BlessedFor.Mana = BlessedFor.ManaMax;
+			}
+
+			base.OnDelete();
+		}
+
+		public override void AddNameProperty(ObjectPropertyList list)
+		{
+			base.AddNameProperty(list);
+
+			list.Add(
+				"<basefont color=#{0:X6}>Cloak: {1} => {2}<basefont color=#FFFFFF>",
+				Color.Gold.ToRgb(),
+				_AccessTemp,
+				_AccessMask);
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			var version = writer.SetVersion(0);
+
+			switch (version)
+			{
+				case 0:
+				{
+					writer.Write(BlessedFor);
+					writer.WriteFlag(_AccessMask);
+					writer.WriteFlag(_AccessTemp);
+				}
+				break;
+			}
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 0:
+				{
+					BlessedFor = reader.ReadMobile();
+
+					_AccessMask = reader.ReadFlag<AccessLevel>();
+					_AccessTemp = reader.ReadFlag<AccessLevel>();
+				}
+				break;
+			}
+		}
+	}
+}

Scripts/SubSystem/VitaNex/Core/Items/Utility/BroadcastScroll.cs

@@ -0,0 +1,501 @@
+#region Header
+//               _,-'/-'/
+//   .      __,-; ,'( '/
+//    \.    `-.__`-._`:_,-._       _ , . ``
+//     `:-._,------' ` _,`--` -: `_ , ` ,' :
+//        `---..__,,--'  (C) 2023  ` -'. -'
+//        #  Vita-Nex [http://core.vita-nex.com]  #
+//  {o)xxx|===============-   #   -===============|xxx(o}
+//        #                                       #
+#endregion
+
+#region References
+using System;
+using System.Drawing;
+using System.Linq;
+
+using Server;
+using Server.Gumps;
+using Server.Items;
+using Server.Mobiles;
+using Server.Network;
+
+using VitaNex.SuperGumps.UI;
+#endregion
+
+namespace VitaNex.Items
+{
+	public class BroadcastScrollGump : TextInputPanelGump<BroadcastScroll>
+	{
+		public bool UseConfirmDialog { get; set; }
+
+		public BroadcastScrollGump(
+			PlayerMobile user,
+			Gump parent = null,
+			BroadcastScroll scroll = null,
+			bool useConfirm = true)
+			: base(
+				user,
+				parent,
+				null,
+				null,
+				400,
+				150,
+				"No scroll selected.",
+				"Broadcast Scroll Message (200 Chars)",
+				null,
+				scroll,
+				null,
+				200)
+		{
+			UseConfirmDialog = useConfirm;
+		}
+
+		protected override void Compile()
+		{
+			if (Selected != null && Selected.Message != Input)
+			{
+				Input = Selected.Message;
+			}
+
+			base.Compile();
+		}
+
+		protected override void ParseInput(string text)
+		{
+			base.ParseInput(text);
+
+			if (Selected != null)
+			{
+				Selected.Message = Input ?? String.Empty;
+			}
+		}
+
+		protected override void CompileMenuOptions(MenuGumpOptions list)
+		{
+			if (Selected != null && !String.IsNullOrWhiteSpace(Selected.Message))
+			{
+				list.AppendEntry(
+					new ListGumpEntry(
+						"Broadcast",
+						b =>
+						{
+							if (Selected != null)
+							{
+								Selected.Message = Input ?? String.Empty;
+								Selected.Broadcast(User);
+							}
+
+							Refresh(true);
+						},
+						HighlightHue));
+
+				list.AppendEntry(
+					new ListGumpEntry(
+						"Clear",
+						b =>
+						{
+							if (Selected != null)
+							{
+								Selected.Message = Input = String.Empty;
+							}
+
+							Refresh(true);
+						},
+						ErrorHue));
+			}
+
+			base.CompileMenuOptions(list);
+		}
+	}
+
+	[Flipable(0xE34, 0xEF3)]
+	public class BroadcastScroll : Item, IUsesRemaining
+	{
+		public static bool Feedback = false;
+
+		private bool _ShowUsesRemaining = true;
+		private int _UsesRemaining = 10;
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public virtual string Message { get; set; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public virtual int MessageHue { get; set; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public virtual int UsesRemaining
+		{
+			get => _UsesRemaining;
+			set
+			{
+				_UsesRemaining = value;
+				InvalidateProperties();
+			}
+		}
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public virtual bool ShowUsesRemaining
+		{
+			get => _ShowUsesRemaining;
+			set
+			{
+				_ShowUsesRemaining = value;
+				InvalidateProperties();
+			}
+		}
+
+		public override bool DisplayLootType => false;
+		public override bool DisplayWeight => false;
+		
+		[Constructable]
+		public BroadcastScroll()
+			: this(1)
+		{ }
+
+		[Constructable]
+		public BroadcastScroll(int uses)
+			: base(0xE34)
+		{
+			UsesRemaining = Math.Max(1, uses);
+
+			Name = "Broadcast Scroll";
+			LootType = LootType.Blessed;
+			Stackable = false;
+			Weight = 0;
+		}
+
+		public BroadcastScroll(Serial serial)
+			: base(serial)
+		{ }
+
+		public void Broadcast(Mobile from)
+		{
+			if (from == null || from.Deleted || !from.Player)
+			{
+				return;
+			}
+
+			if (!IsChildOf(from.Backpack) || !IsAccessibleTo(from) || !from.CanSee(this) || InSecureTrade)
+			{
+				return;
+			}
+
+			if (String.IsNullOrWhiteSpace(Message))
+			{
+				new NoticeDialogGump(from)
+				{
+					Title = "Empty Message",
+					Html = "Your broadcast message can't be blank and can't consist only of white-space."
+				}.Send();
+
+				return;
+			}
+
+			if (Deleted || UsesRemaining <= 0)
+			{
+				if (from is PlayerMobile)
+				{
+					new NoticeDialogGump((PlayerMobile)from)
+					{
+						Title = "Scroll Exhausted",
+						Html = "Your broadcast scroll has been exhausted, you can't send another message."
+					}.Send();
+				}
+
+				return;
+			}
+
+			//Send the message to all online players, including staff.
+			int reach = 0, staff = 0;
+
+			foreach (var state in NetState.Instances.Where(ns => ns != null && ns.Running && ns.Mobile != null))
+			{
+				state.Mobile.SendMessage(MessageHue > 0 ? MessageHue : from.SpeechHue, "Message from {0}:", from.RawName);
+				state.Mobile.SendMessage(MessageHue > 0 ? MessageHue : from.SpeechHue, Message);
+
+				if (state.Mobile == from || (DateTime.UtcNow - state.ConnectedOn) < TimeSpan.FromMinutes(1))
+				{
+					continue;
+				}
+
+				//If receiver is not sender and receiver has been logged in for over 1 minute, include them in total reached.
+				reach++;
+
+				if (state.Mobile.AccessLevel >= AccessLevel.Counselor)
+				{
+					staff++;
+				}
+			}
+
+			//If we reached people and they weren't just staff, charge for the message.
+			if (reach - staff > 0)
+			{
+				if (Feedback)
+				{
+					from.SendMessage(0x55, "Your broadcast was seen by {0:#,0} people!", reach);
+				}
+
+				if (--UsesRemaining <= 0)
+				{
+					from.SendMessage(0x22, "Your broadcast scroll has been exhausted, you throw away the scrap paper.");
+					Delete();
+				}
+			}
+			else
+			{
+				from.SendMessage(0x22, "Your broadcast was not seen by anyone, your scroll was not consumed this time.");
+			}
+		}
+
+		public override void OnDoubleClick(Mobile from)
+		{
+			base.OnDoubleClick(from);
+
+			if (!this.CheckDoubleClick(from, true, true, 2, true))
+			{
+				return;
+			}
+
+			if (from is PlayerMobile && UsesRemaining > 0)
+			{
+				new BroadcastScrollGump((PlayerMobile)from, scroll: this).Send();
+			}
+		}
+
+		public override void GetProperties(ObjectPropertyList list)
+		{
+			base.GetProperties(list);
+
+			if (ShowUsesRemaining)
+			{
+				// uses remaining: ~1_val~
+				list.Add(1060584, UsesRemaining == Int32.MaxValue ? "unlimited" : String.Format("{0:#,0}", UsesRemaining));
+			}
+
+			list.Add("Use: Broadcast A Global Message".WrapUOHtmlColor(Color.SkyBlue));
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			var version = writer.SetVersion(0);
+
+			switch (version)
+			{
+				case 0:
+				{
+					writer.Write(Message);
+					writer.Write(_UsesRemaining);
+					writer.Write(_ShowUsesRemaining);
+				}
+				break;
+			}
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 0:
+				{
+					Message = reader.ReadString();
+					_UsesRemaining = reader.ReadInt();
+					_ShowUsesRemaining = reader.ReadBool();
+				}
+				break;
+			}
+		}
+	}
+
+	public class BroadcastScroll_Unlimited : BroadcastScroll
+	{
+		public override int UsesRemaining { get => Int32.MaxValue; set { } }
+
+		[Constructable]
+		public BroadcastScroll_Unlimited()
+			: base(Int32.MaxValue)
+		{
+			ShowUsesRemaining = false;
+		}
+
+		public BroadcastScroll_Unlimited(Serial serial)
+			: base(serial)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.SetVersion(0);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.GetVersion();
+		}
+	}
+
+	public class BroadcastScroll_3Uses : BroadcastScroll
+	{
+		[Constructable]
+		public BroadcastScroll_3Uses()
+			: base(3)
+		{ }
+
+		public BroadcastScroll_3Uses(Serial serial)
+			: base(serial)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.SetVersion(0);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.GetVersion();
+		}
+	}
+
+	public class BroadcastScroll_5Uses : BroadcastScroll
+	{
+		[Constructable]
+		public BroadcastScroll_5Uses()
+			: base(5)
+		{ }
+
+		public BroadcastScroll_5Uses(Serial serial)
+			: base(serial)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.SetVersion(0);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.GetVersion();
+		}
+	}
+
+	public class BroadcastScroll_10Uses : BroadcastScroll
+	{
+		[Constructable]
+		public BroadcastScroll_10Uses()
+			: base(10)
+		{ }
+
+		public BroadcastScroll_10Uses(Serial serial)
+			: base(serial)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.SetVersion(0);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.GetVersion();
+		}
+	}
+
+	public class BroadcastScroll_30Uses : BroadcastScroll
+	{
+		[Constructable]
+		public BroadcastScroll_30Uses()
+			: base(30)
+		{ }
+
+		public BroadcastScroll_30Uses(Serial serial)
+			: base(serial)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.SetVersion(0);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.GetVersion();
+		}
+	}
+
+	public class BroadcastScroll_50Uses : BroadcastScroll
+	{
+		[Constructable]
+		public BroadcastScroll_50Uses()
+			: base(50)
+		{ }
+
+		public BroadcastScroll_50Uses(Serial serial)
+			: base(serial)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.SetVersion(0);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.GetVersion();
+		}
+	}
+
+	public class BroadcastScroll_100Uses : BroadcastScroll
+	{
+		[Constructable]
+		public BroadcastScroll_100Uses()
+			: base(100)
+		{ }
+
+		public BroadcastScroll_100Uses(Serial serial)
+			: base(serial)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.SetVersion(0);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.GetVersion();
+		}
+	}
+}

Scripts/SubSystem/VitaNex/Core/Items/Utility/FloorTiles.cs

@@ -0,0 +1,407 @@
+#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.Items
+{
+	public abstract class FloorTile<TMob> : Item
+		where TMob : Mobile
+	{
+		public override double DefaultWeight => 0;
+		public override bool DisplayWeight => false;
+		public override bool DisplayLootType => false;
+		public override bool Decays => false;
+
+		public Func<TMob, bool> MoveOverHandler { get; set; }
+		public Func<TMob, bool> MoveOffHandler { get; set; }
+
+		public FloorTile()
+			: this(null, null)
+		{ }
+
+		public FloorTile(Func<TMob, bool> moveOver, Func<TMob, bool> moveOff)
+			: base(9272)
+		{
+			MoveOverHandler = moveOver;
+			MoveOffHandler = moveOff;
+
+			Name = "Floor Tile";
+			Movable = false;
+			Visible = false;
+		}
+
+		public FloorTile(Serial serial)
+			: base(serial)
+		{ }
+
+		public override sealed bool OnMoveOver(Mobile m)
+		{
+			if (m == null || m.Deleted || !(m is TMob))
+			{
+				return base.OnMoveOver(m);
+			}
+
+			return OnMoveOver(m as TMob);
+		}
+
+		public virtual bool OnMoveOver(TMob mob)
+		{
+			if (base.OnMoveOver(mob))
+			{
+				if (MoveOverHandler != null)
+				{
+					return MoveOverHandler(mob);
+				}
+
+				return true;
+			}
+
+			return false;
+		}
+
+		public override sealed bool OnMoveOff(Mobile m)
+		{
+			if (m == null || m.Deleted || !(m is TMob))
+			{
+				return base.OnMoveOff(m);
+			}
+
+			return OnMoveOff(m as TMob);
+		}
+
+		public virtual bool OnMoveOff(TMob mob)
+		{
+			if (base.OnMoveOff(mob))
+			{
+				if (MoveOffHandler != null)
+				{
+					return MoveOffHandler(mob);
+				}
+
+				return true;
+			}
+
+			return false;
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.SetVersion(0);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.GetVersion();
+		}
+	}
+
+	public abstract class RestrictMobileTile<TMob> : FloorTile<TMob>
+		where TMob : Mobile
+	{
+		[CommandProperty(AccessLevel.GameMaster)]
+		public bool Restricted { get; set; }
+
+		public RestrictMobileTile()
+			: this(null, null)
+		{ }
+
+		public RestrictMobileTile(Func<TMob, bool> moveOver, Func<TMob, bool> moveOff)
+			: base(moveOver, moveOff)
+		{
+			Restricted = true;
+			Name = "Restrict Mobiles";
+		}
+
+		public RestrictMobileTile(Serial serial)
+			: base(serial)
+		{ }
+
+		public override bool OnMoveOver(TMob m)
+		{
+			if (base.OnMoveOver(m))
+			{
+				return !Restricted;
+			}
+
+			return false;
+		}
+
+		public override bool OnMoveOff(TMob m)
+		{
+			if (base.OnMoveOff(m))
+			{
+				return !Restricted;
+			}
+
+			return false;
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			var version = writer.SetVersion(0);
+
+			switch (version)
+			{
+				case 0:
+					writer.Write(Restricted);
+					break;
+			}
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 0:
+					Restricted = reader.ReadBool();
+					break;
+			}
+		}
+	}
+
+	public class RestrictMobileTile : RestrictMobileTile<Mobile>
+	{
+		[Constructable]
+		public RestrictMobileTile()
+			: this(null, null)
+		{ }
+
+		public RestrictMobileTile(Func<Mobile, bool> moveOver, Func<Mobile, bool> moveOff)
+			: base(moveOver, moveOff)
+		{
+			Name = "Restrict Mobiles";
+		}
+
+		public RestrictMobileTile(Serial serial)
+			: base(serial)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.SetVersion(0);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			reader.GetVersion();
+		}
+	}
+
+	public class RestrictCreatureTile : RestrictMobileTile<BaseCreature>
+	{
+		[CommandProperty(AccessLevel.GameMaster)]
+		public bool AllowControlled { get; set; }
+
+		[Constructable]
+		public RestrictCreatureTile()
+			: this(null, null)
+		{ }
+
+		public RestrictCreatureTile(Func<BaseCreature, bool> moveOver, Func<BaseCreature, bool> moveOff)
+			: base(moveOver, moveOff)
+		{
+			AllowControlled = true;
+			Name = "Restrict Creatures";
+		}
+
+		public RestrictCreatureTile(Serial serial)
+			: base(serial)
+		{ }
+
+		public override bool OnMoveOver(BaseCreature m)
+		{
+			if (!base.OnMoveOver(m))
+			{
+				if (m.Controlled && AllowControlled)
+				{
+					return true;
+				}
+
+				return false;
+			}
+
+			return true;
+		}
+
+		public override bool OnMoveOff(BaseCreature m)
+		{
+			if (!base.OnMoveOff(m))
+			{
+				if (m.Controlled && AllowControlled)
+				{
+					return true;
+				}
+
+				return false;
+			}
+
+			return true;
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			var version = writer.SetVersion(0);
+
+			switch (version)
+			{
+				case 0:
+					writer.Write(AllowControlled);
+					break;
+			}
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 0:
+					AllowControlled = reader.ReadBool();
+					break;
+			}
+		}
+	}
+
+	public class RestrictPlayerTile : RestrictMobileTile<PlayerMobile>
+	{
+		[CommandProperty(AccessLevel.GameMaster)]
+		public bool AllowDead { get; set; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public bool AllowYoung { get; set; }
+
+		[Constructable]
+		public RestrictPlayerTile()
+			: this(null, null)
+		{ }
+
+		public RestrictPlayerTile(Func<PlayerMobile, bool> moveOver, Func<PlayerMobile, bool> moveOff)
+			: base(moveOver, moveOff)
+		{
+			AllowYoung = true;
+			AllowDead = true;
+			Name = "Restrict Players";
+		}
+
+		public RestrictPlayerTile(Serial serial)
+			: base(serial)
+		{ }
+
+		public override bool OnMoveOver(PlayerMobile m)
+		{
+			if (m.Player && m.AccessLevel > AccessLevel.Counselor)
+			{
+				return true;
+			}
+
+			if (!base.OnMoveOver(m))
+			{
+				if (!m.Alive && AllowDead)
+				{
+					return true;
+				}
+
+				if (m.Young && AllowYoung)
+				{
+					return true;
+				}
+
+				return false;
+			}
+
+			return true;
+		}
+
+		public override bool OnMoveOff(PlayerMobile m)
+		{
+			if (m.Player && m.AccessLevel > AccessLevel.Counselor)
+			{
+				return true;
+			}
+
+			if (!base.OnMoveOff(m))
+			{
+				if (!m.Alive && AllowDead)
+				{
+					return true;
+				}
+
+				if (m.Young && AllowYoung)
+				{
+					return true;
+				}
+
+				return false;
+			}
+
+			return true;
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			var version = writer.SetVersion(0);
+
+			switch (version)
+			{
+				case 0:
+				{
+					writer.Write(AllowDead);
+					writer.Write(AllowYoung);
+				}
+				break;
+			}
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.GetVersion();
+
+			switch (version)
+			{
+				case 0:
+				{
+					AllowDead = reader.ReadBool();
+					AllowYoung = reader.ReadBool();
+				}
+				break;
+			}
+		}
+	}
+}