ModernUO/Scripts/Items/Containers/MarkContainer.cs

using System;
using Server.Commands;

namespace Server.Items
{
	public class MarkContainer : LockableContainer
	{
		public static void Initialize()
		{
			CommandSystem.Register( "SecretLocGen", AccessLevel.Administrator, SecretLocGen_OnCommand );
		}

		[Usage( "SecretLocGen" )]
		[Description( "Generates mark containers to Malas secret locations." )]
		public static void SecretLocGen_OnCommand( CommandEventArgs e )
		{
			CreateMalasPassage( 951, 546, -70, 1006, 994, -70, false, false );
			CreateMalasPassage( 914, 192, -79, 1019, 1062, -70, false, false );
			CreateMalasPassage( 1614, 143, -90, 1214, 1313, -90, false, false );
			CreateMalasPassage( 2176, 324, -90, 1554, 172, -90, false, false );
			CreateMalasPassage( 864, 812, -90, 1061, 1161, -70, false, false );
			CreateMalasPassage( 1051, 1434, -85, 1076, 1244, -70, false, true );
			CreateMalasPassage( 1326, 523, -87, 1201, 1554, -70, false, false );
			CreateMalasPassage( 424, 189, -1, 2333, 1501, -90, true, false );
			CreateMalasPassage( 1313, 1115, -85, 1183, 462, -45, false, false );

			e.Mobile.SendMessage( "Secret mark containers have been created." );
		}

		private static bool FindMarkContainer( Point3D p, Map map )
		{
			IPooledEnumerable<MarkContainer> eable = map.GetItemsInRange<MarkContainer>( p, 0 );

			foreach ( Item item in eable )
			{
				if ( item.Z == p.Z )
				{
					eable.Free();
					return true;
				}
			}

			eable.Free();
			return false;
		}

		private static void CreateMalasPassage( int x, int y, int z, int xTarget, int yTarget, int zTarget, bool bone, bool locked )
		{
			Point3D location = new Point3D( x, y, z );

			if ( FindMarkContainer( location, Map.Malas ) )
				return;

			MarkContainer cont = new MarkContainer( bone, locked );
			cont.TargetMap = Map.Malas;
			cont.Target = new Point3D( xTarget, yTarget, zTarget );
			cont.Description = "strange location";

			cont.MoveToWorld( location, Map.Malas );
		}

		private bool m_AutoLock;
		private InternalTimer m_RelockTimer;

		[CommandProperty( AccessLevel.GameMaster )]
		public bool AutoLock
		{
			get => m_AutoLock;
			set
			{
				m_AutoLock = value;

				if ( !m_AutoLock )
					StopTimer();
				else if ( !Locked && m_RelockTimer == null )
					m_RelockTimer = new InternalTimer( this );
			}
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public Map TargetMap { get; set; }

		[CommandProperty( AccessLevel.GameMaster )]
		public Point3D Target { get; set; }

		[CommandProperty( AccessLevel.GameMaster )]
		public bool Bone
		{
			get => ItemID == 0xECA;
			set
			{
				ItemID = value ? 0xECA : 0xE79;
				Hue = value ? 1102 : 0;
			}
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public string Description { get; set; }

		public override bool IsDecoContainer => false;

		[Constructible]
		public MarkContainer() : this( false )
		{
		}

		[Constructible]
		public MarkContainer( bool bone ) : this( bone, false )
		{
		}

		[Constructible]
		public MarkContainer( bool bone, bool locked ) : base( bone ? 0xECA : 0xE79 )
		{
			Movable = false;

			if ( bone )
				Hue = 1102;

			m_AutoLock = locked;
			Locked = locked;

			if ( locked )
				LockLevel = -255;
		}

		public MarkContainer( Serial serial ) : base( serial )
		{
		}

		[CommandProperty( AccessLevel.GameMaster )]
		public override bool Locked
		{
			get => base.Locked;
			set
			{
				base.Locked = value;

				if ( m_AutoLock )
				{
					StopTimer();

					if ( !Locked )
						m_RelockTimer = new InternalTimer( this );
				}
			}
		}

		public void StopTimer()
		{
			m_RelockTimer?.Stop();

			m_RelockTimer = null;
		}

		private class InternalTimer : Timer
		{
			public MarkContainer Container { get; }

			public DateTime RelockTime { get; }

			public InternalTimer( MarkContainer container ) : this( container, TimeSpan.FromMinutes( 5.0 ) )
			{
			}

			public InternalTimer( MarkContainer container, TimeSpan delay ) : base( delay )
			{
				Container = container;
				RelockTime = DateTime.UtcNow + delay;

				Start();
			}

			protected override void OnTick()
			{
				Container.Locked = true;
				Container.LockLevel = -255;
			}
		}

		public void Mark( RecallRune rune )
		{
			if ( TargetMap != null )
			{
				rune.Marked = true;
				rune.TargetMap = TargetMap;
				rune.Target = Target;
				rune.Description = Description;
				rune.House = null;
			}
		}

		public override bool OnDragDrop( Mobile from, Item dropped )
		{
			if ( dropped is RecallRune rune && base.OnDragDrop( from, dropped ) )
			{
				Mark( rune );
				return true;
			}

			return false;
		}

		public override bool OnDragDropInto( Mobile from, Item dropped, Point3D p )
		{
			if ( dropped is RecallRune rune && base.OnDragDropInto( from, dropped, p ) )
			{
				Mark( rune );
				return true;
			}

			return false;
		}

		public override void Serialize( GenericWriter writer )
		{
			base.Serialize( writer );

			writer.Write( (int)0 ); // version

			writer.Write( m_AutoLock );

			if ( !Locked && m_AutoLock )
				writer.WriteDeltaTime( m_RelockTimer.RelockTime );

			writer.Write( TargetMap );
			writer.Write( Target );
			writer.Write( Description );
		}

		public override void Deserialize( GenericReader reader )
		{
			base.Deserialize( reader );

			int version = reader.ReadInt();

			m_AutoLock = reader.ReadBool();

			if ( !Locked && m_AutoLock )
				m_RelockTimer = new InternalTimer( this, reader.ReadDeltaTime() - DateTime.UtcNow );

			TargetMap = reader.ReadMap();
			Target = reader.ReadPoint3D();
			Description = reader.ReadString();
		}
	}
}