MoveTriggerTile.cs

using System;
using System.Collections.Generic;

using Server;
using Server.Mobiles;


namespace Server.Items
{
    public class MoveTriggerTile : BaseTriggerTile
    {
        public override string DefaultName { get { return "A Move Trigger Tile"; } }

        //What/Where/How Long type infos
        private Point3D m_WhereToMove;
        private Point3D m_OldLocation;
        private TimeSpan m_MoveDuration = TimeSpan.Zero;
        private TimeSpan m_MoveDelay = TimeSpan.Zero;
        private Item m_MoveTarget;
        private bool moved = false;

        [CommandProperty(AccessLevel.GameMaster)]
        public Point3D WhereToMove
        {
            get { return m_WhereToMove; }
            set { m_WhereToMove = value; }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public TimeSpan MoveDuration
        {
            get { return m_MoveDuration; }
            set
            {
                if (value == TimeSpan.Zero)
                    MoveDelay = TimeSpan.Zero;
                m_MoveDuration = value;
            }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public TimeSpan MoveDelay
        {
            get { return m_MoveDelay; }
            set
            {
                if (MoveDuration > TimeSpan.Zero)
                    m_MoveDelay = value;
            }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public Item MoveTarget
        {
            get { return m_MoveTarget; }
            set { m_MoveTarget = value; }
        }


        //Who is triggering it? (in case multiple for 0 duration timer)
        private List<Mobile> TriggeredMobiles = new List<Mobile>();


        [Constructable]
        public MoveTriggerTile() : base()
        {

        }

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

        public override bool OnMoveOver(Mobile m)
        {
            if (base.OnMoveOver(m))
            {
                if ((MoveTarget == null || MoveTarget.Deleted))
                    return true;

                if(!moved)
                    Timer.DelayCall(MoveDelay, new TimerCallback(DoMove));

                moved = true;

                if (!TriggeredMobiles.Contains(m) && MoveDuration == TimeSpan.Zero)
                {
                    TriggeredMobiles.Add(m);
                    Timer.DelayCall(TimeSpan.FromSeconds(.25), new TimerStateCallback(CheckTriggeredMobiles), m);
                }

                if (Effects != null && !Effects.Deleted)
                {
                    Timer.DelayCall(EffectsDelay, new TimerStateCallback(Effects.DoEffect), m);
                }                
            }

            return true;
        }

        private void CheckTriggeredMobiles(object state)
        {
            Mobile m = (Mobile)state;

            if (m.X == this.X && m.Y == this.Y && m.Map == this.Map)
                Timer.DelayCall(TimeSpan.FromSeconds(.25), new TimerStateCallback(CheckTriggeredMobiles), m);
            else
                OnMoveOff(m);
        }

        public override bool OnMoveOff(Mobile m)
        {
            if (TriggeredMobiles.Contains(m))
                TriggeredMobiles.Remove(m);

            if(MoveDuration == TimeSpan.Zero && TriggeredMobiles.Count == 0)
                RevertMove();

            return true;
        }

        private void DoMove()
        {
            if (MoveTarget == null || MoveTarget.Deleted)
                return;

            m_OldLocation = MoveTarget.Location;
            MoveTarget.Location = WhereToMove;

            if (MoveDuration != TimeSpan.Zero)
                Timer.DelayCall(MoveDuration, new TimerCallback(RevertMove));                
        }

        private void RevertMove()
        {
            if (MoveTarget == null || MoveTarget.Deleted)
                return;

            if (moved)
                MoveTarget.Location = m_OldLocation;

            moved = false;
        }

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

            writer.Write(m_OldLocation);
            writer.Write(moved);

            writer.Write(WhereToMove);
            writer.Write(MoveDuration);
            writer.Write(MoveDelay);
            writer.Write(MoveTarget);
        }

        public override void Deserialize(GenericReader reader)
        {
            base.Deserialize(reader);
            int version = reader.ReadInt();

            m_OldLocation = reader.ReadPoint3D();
            moved = reader.ReadBool();

            WhereToMove = reader.ReadPoint3D();
            MoveDuration = reader.ReadTimeSpan();
            MoveDelay = reader.ReadTimeSpan();
            MoveTarget = reader.ReadItem();

            if (moved == true)
            {
                MoveTarget.Location = m_OldLocation;
                moved = false;
            }
        }
    }
}