Overwrite

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

Scripts/Items/Internal/AbyssBarrier.cs

@@ -0,0 +1,66 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Mobiles;
+using Server.Network;
+using Server.Regions;
+
+namespace Server.Items
+{
+    public class AbyssBarrier : Item
+    {
+      
+        [Constructable]
+        public AbyssBarrier() : base(0x49E)
+        {
+            Movable = false;
+            Visible = false;
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            PlayerMobile mobile = m as PlayerMobile;
+
+            if (m.IsStaff())
+                return true;
+            else if (mobile != null)
+            {
+
+                if (mobile.AbyssEntry == false)
+                {
+                    m.SendLocalizedMessage(1112226);
+                    return false;
+                }
+                else
+                {
+                    m.SendLocalizedMessage(1113708);
+                    return true;
+                }
+            }
+            else
+                return false;
+        }
+
+        public AbyssBarrier(Serial serial): base(serial)
+        {
+        }
+
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            }
+        }
+    }
+
+	

Scripts/Items/Internal/AcidSlime.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class AcidSlime : Item
+    {
+        private readonly TimeSpan m_Duration;
+        private readonly int m_MinDamage;
+        private readonly int m_MaxDamage;
+        private readonly DateTime m_Created;
+        private readonly Timer m_Timer;
+        private bool m_Drying;
+		
+		public override int LabelNumber {get {return 1018143;} } // slime
+		
+        [Constructable]
+        public AcidSlime()
+            : this(TimeSpan.FromSeconds(10.0), 5, 10)
+        {
+        }
+
+        [Constructable]
+        public AcidSlime(TimeSpan duration, int minDamage, int maxDamage)
+            : base(0x122A)
+        {
+            Hue = 0x3F;
+            Movable = false;
+            m_MinDamage = minDamage;
+            m_MaxDamage = maxDamage;
+            m_Created = DateTime.UtcNow;
+            m_Duration = duration;
+            m_Timer = Timer.DelayCall(TimeSpan.Zero, TimeSpan.FromSeconds(1), new TimerCallback(OnTick));
+        }
+
+        public AcidSlime(Serial serial)
+            : base(serial)
+        {
+        }
+       
+        public override void OnAfterDelete()
+        {
+            if (this.m_Timer != null)
+                this.m_Timer.Stop();
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            this.Damage(m);
+            return true;
+        }
+
+        public void Damage(Mobile m)
+        {
+            int damage = Utility.RandomMinMax(this.m_MinDamage, this.m_MaxDamage);
+            if (Core.AOS)
+                AOS.Damage(m, damage, 0, 0, 0, 100, 0);
+            else
+                m.Damage(damage);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+        }
+
+        private void OnTick()
+        {
+            DateTime now = DateTime.UtcNow;
+            TimeSpan age = now - this.m_Created;
+
+            if (age > this.m_Duration)
+            {
+                this.Delete();
+            }
+            else
+            {
+                if (!this.m_Drying && age > (this.m_Duration - age))
+                {
+                    this.m_Drying = true;
+                    this.ItemID = 0x122B;
+                }
+
+                List<Mobile> toDamage = new List<Mobile>();
+                IPooledEnumerable eable = GetMobilesInRange(0);
+
+                foreach (Mobile m in eable)
+                {
+                    BaseCreature bc = m as BaseCreature;
+                    if (m.Alive && !m.IsDeadBondedPet && (bc == null || bc.Controlled || bc.Summoned))
+                    {
+                        toDamage.Add(m);
+                    }
+                }
+                eable.Free();
+
+                for (int i = 0; i < toDamage.Count; i++)
+                    this.Damage(toDamage[i]);
+            }
+        }
+    }
+}

Scripts/Items/Internal/Beard.cs

@@ -0,0 +1,331 @@
+using System;
+
+namespace Server.Items
+{
+    public abstract class Beard : Item
+    {
+        public Beard(Serial serial)
+            : base(serial)
+        {
+        }
+
+        /*public static Beard CreateByID( int id, int hue )
+        {
+        switch ( id )
+        {
+        case 0x203E: return new LongBeard( hue );
+        case 0x203F: return new ShortBeard( hue );
+        case 0x2040: return new Goatee( hue );
+        case 0x2041: return new Mustache( hue );
+        case 0x204B: return new MediumShortBeard( hue );
+        case 0x204C: return new MediumLongBeard( hue );
+        case 0x204D: return new Vandyke( hue );
+        default: return new GenericBeard( id, hue );
+        }
+        }*/
+        protected Beard(int itemID)
+            : this(itemID, 0)
+        {
+        }
+
+        protected Beard(int itemID, int hue)
+            : base(itemID)
+        {
+            this.LootType = LootType.Blessed;
+            this.Layer = Layer.FacialHair;
+            this.Hue = hue;
+        }
+
+        public override bool DisplayLootType
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override bool VerifyMove(Mobile from)
+        {
+            return (from.AccessLevel >= AccessLevel.GameMaster);
+        }
+
+        public override DeathMoveResult OnParentDeath(Mobile parent)
+        {
+            //Dupe( Amount );
+            parent.FacialHairItemID = this.ItemID;
+            parent.FacialHairHue = this.Hue;
+
+            return DeathMoveResult.MoveToCorpse;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            this.LootType = LootType.Blessed;
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GenericBeard : Beard
+    {
+        public GenericBeard(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private GenericBeard(int itemID)
+            : this(itemID, 0)
+        {
+        }
+
+        private GenericBeard(int itemID, int hue)
+            : base(itemID, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class LongBeard : Beard
+    {
+        public LongBeard(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private LongBeard()
+            : this(0)
+        {
+        }
+
+        private LongBeard(int hue)
+            : base(0x203E, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class ShortBeard : Beard
+    {
+        public ShortBeard(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private ShortBeard()
+            : this(0)
+        {
+        }
+
+        private ShortBeard(int hue)
+            : base(0x203f, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class Goatee : Beard
+    {
+        public Goatee(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private Goatee()
+            : this(0)
+        {
+        }
+
+        private Goatee(int hue)
+            : base(0x2040, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class Mustache : Beard
+    {
+        public Mustache(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private Mustache()
+            : this(0)
+        {
+        }
+
+        private Mustache(int hue)
+            : base(0x2041, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class MediumShortBeard : Beard
+    {
+        public MediumShortBeard(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private MediumShortBeard()
+            : this(0)
+        {
+        }
+
+        private MediumShortBeard(int hue)
+            : base(0x204B, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class MediumLongBeard : Beard
+    {
+        public MediumLongBeard(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private MediumLongBeard()
+            : this(0)
+        {
+        }
+
+        private MediumLongBeard(int hue)
+            : base(0x204C, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class Vandyke : Beard
+    {
+        public Vandyke(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private Vandyke()
+            : this(0)
+        {
+        }
+
+        private Vandyke(int hue)
+            : base(0x204D, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/BedlamTeleporters.cs

@@ -0,0 +1,81 @@
+using System;
+using Server.Engines.Quests;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class BedlamTele : Item
+    {
+        [Constructable]
+        public BedlamTele()
+            : base(0x124D)
+        {
+            Movable = false;
+        }
+
+        public BedlamTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1074161;
+            }
+        }// Access to Bedlam by invitation only
+        
+        public override bool ForceShowProperties { get { return ObjectPropertyList.Enabled; } }
+        
+        public virtual Type Quest
+        {
+            get
+            {
+                return typeof(MistakenIdentityQuest);
+            }
+        }
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (from.NetState == null || !from.NetState.SupportsExpansion(Expansion.ML))
+            {
+                from.SendLocalizedMessage(1072608); // You must upgrade to the Mondain's Legacy expansion in order to enter here.					
+                return;
+            }
+            else if (!MondainsLegacy.Bedlam && (int)from.AccessLevel < (int)AccessLevel.GameMaster)
+            {
+                from.SendLocalizedMessage(1042753, "Bedlam"); // ~1_SOMETHING~ has been temporarily disabled.
+                return;
+            }
+		
+            if (from is PlayerMobile)
+            {
+                PlayerMobile player = (PlayerMobile)from;
+
+                if (player.Bedlam)
+                {
+                    BaseCreature.TeleportPets(player, new Point3D(121, 1682, 0), this.Map);
+                    player.MoveToWorld(new Point3D(121, 1682, 0), this.Map);
+                }
+                else
+                {
+                    player.SendLocalizedMessage(1074276); // You press and push on the iron maiden, but nothing happens.
+                }
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+			
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/BlightedGroveTeleporters.cs

@@ -0,0 +1,149 @@
+using System;
+
+namespace Server.Items
+{ 
+    public class BlightedGroveTele : Teleporter
+    { 
+        [Constructable]
+        public BlightedGroveTele()
+            : base()
+        {
+        }
+
+        public BlightedGroveTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public static BoneMachete GetBoneMachete(Mobile m)
+        {
+            for (int i = 0; i < m.Items.Count; i ++)
+            {
+                if (m.Items[i] is BoneMachete)
+                    return (BoneMachete)m.Items[i];
+            }
+			
+            if (m.Backpack != null)
+                return m.Backpack.FindItemByType(typeof(BoneMachete), true) as BoneMachete;
+				
+            return null;
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (m.NetState == null || !m.NetState.SupportsExpansion(Expansion.ML))
+            {
+                m.SendLocalizedMessage(1072608); // You must upgrade to the Mondain's Legacy expansion in order to enter here.				
+                return true;
+            }
+            else if (!MondainsLegacy.BlightedGrove && (int)m.AccessLevel < (int)AccessLevel.GameMaster)
+            {
+                m.SendLocalizedMessage(1042753, "Blighted Grove"); // ~1_SOMETHING~ has been temporarily disabled.
+                return true;
+            }
+			
+            BoneMachete machete = GetBoneMachete(m);
+			
+            if (machete != null)
+            {
+                if (0.6 > Utility.RandomDouble())
+                {
+                    m.SendLocalizedMessage(1075008); // Your bone handled machete has grown dull but you still manage to force your way past the venomous branches.
+                }
+                else
+                {
+                    machete.Delete();
+                    m.SendLocalizedMessage(1075007); // Your bone handled machete snaps in half as you force your way through the poisonous undergrowth.
+                }
+				
+                return base.OnMoveOver(m);
+            }
+            else
+                m.SendLocalizedMessage(1074275); // You are unable to push your way through the tangling roots of the mighty tree.
+				
+            return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class BlightedGroveTreeInTele : Teleporter
+    { 
+        [Constructable]
+        public BlightedGroveTreeInTele()
+            : base()
+        {
+        }
+
+        public BlightedGroveTreeInTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            m.SendLocalizedMessage(1074162); // You notice a hole in the tree and climb down
+            return base.OnMoveOver(m);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class BlightedGroveTreeOutTele : Teleporter
+    { 
+        [Constructable]
+        public BlightedGroveTreeOutTele()
+            : base()
+        {
+        }
+
+        public BlightedGroveTreeOutTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            m.SendLocalizedMessage(1074163); // You find a way to climb back outside the tree
+            return base.OnMoveOver(m);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/Blocker.cs

@@ -0,0 +1,114 @@
+using System;
+using Server.Network;
+
+namespace Server.Items
+{
+    public class Blocker : Item
+    {
+        [Constructable]
+        public Blocker()
+            : base(0x21A4)
+        {
+            this.Movable = false;
+        }
+
+        public Blocker(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 503057;
+            }
+        }// Impassable!
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        protected override Packet GetWorldPacketFor(NetState state)
+        {
+            Mobile mob = state.Mobile;
+
+            if (mob != null && mob.AccessLevel >= AccessLevel.GameMaster)
+                return new GMItemPacket(this);
+
+            return base.GetWorldPacketFor(state);
+        }
+
+        public sealed class GMItemPacket : Packet
+        {
+            public GMItemPacket(Item item)
+                : base(0x1A)
+            {
+                this.EnsureCapacity(20);
+
+                // 14 base length
+                // +2 - Amount
+                // +2 - Hue
+                // +1 - Flags
+
+                uint serial = (uint)item.Serial.Value;
+                int itemID = 0x1183;
+                int amount = item.Amount;
+                Point3D loc = item.Location;
+                int x = loc.X;
+                int y = loc.Y;
+                int hue = item.Hue;
+                int flags = item.GetPacketFlags();
+                int direction = (int)item.Direction;
+
+                if (amount != 0)
+                    serial |= 0x80000000;
+                else
+                    serial &= 0x7FFFFFFF;
+
+                this.m_Stream.Write((uint)serial);
+				this.m_Stream.Write((short)(itemID & TileData.MaxItemValue));
+
+                if (amount != 0)
+                    this.m_Stream.Write((short)amount);
+
+                x &= 0x7FFF;
+
+                if (direction != 0)
+                    x |= 0x8000;
+
+                this.m_Stream.Write((short)x);
+
+                y &= 0x3FFF;
+
+                if (hue != 0)
+                    y |= 0x8000;
+
+                if (flags != 0)
+                    y |= 0x4000;
+
+                this.m_Stream.Write((short)y);
+
+                if (direction != 0)
+                    this.m_Stream.Write((byte)direction);
+
+                this.m_Stream.Write((sbyte)loc.Z);
+
+                if (hue != 0)
+                    this.m_Stream.Write((ushort)hue);
+
+                if (flags != 0)
+                    this.m_Stream.Write((byte)flags);
+            }
+        }
+    }
+}

Scripts/Items/Internal/BlueNinjaQuestTeleporter.cs

@@ -0,0 +1,62 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Engines.Quests.Ninja
+{
+    public class BlueNinjaQuestTeleporter : DynamicTeleporter
+    {
+        [Constructable]
+        public BlueNinjaQuestTeleporter()
+            : base(0x51C, 0x2)
+        {
+        }
+
+        public BlueNinjaQuestTeleporter(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1026157;
+            }
+        }// teleporter
+        public override int NotWorkingMessage
+        {
+            get
+            {
+                return 1063198;
+            }
+        }// You stand on the strange floor tile but nothing happens.
+        public override bool GetDestination(PlayerMobile player, ref Point3D loc, ref Map map)
+        {
+            QuestSystem qs = player.Quest;
+
+            if (qs is EminosUndertakingQuest && qs.FindObjective(typeof(GainInnInformationObjective)) != null)
+            {
+                loc = new Point3D(411, 1116, 0);
+                map = Map.Malas;
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/CitadelTeleporters.cs

@@ -0,0 +1,64 @@
+using System;
+using Server.Engines.Quests;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class CitadelTele : Item
+    { 
+        [Constructable]
+        public CitadelTele()
+            : base(0xE3F)
+        {
+            Movable = false;
+        }
+
+        public CitadelTele(Serial serial)
+            : base(serial)
+        {
+        }
+        
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (from.NetState == null || !from.NetState.SupportsExpansion(Expansion.ML))
+            {
+                from.SendLocalizedMessage(1072608); // You must upgrade to the Mondain's Legacy expansion in order to enter here.				
+                return;
+            }
+            else if (!MondainsLegacy.Citadel && (int)from.AccessLevel < (int)AccessLevel.GameMaster)
+            {
+                from.SendLocalizedMessage(1042753, "The Citadel"); // ~1_SOMETHING~ has been temporarily disabled.
+                return;
+            }
+		
+            if (from is PlayerMobile)
+            {
+                PlayerMobile player = (PlayerMobile)from;
+				
+                if (QuestHelper.GetQuest(player, typeof(BlackOrderBadgesQuest)) != null || QuestHelper.GetQuest(player, typeof(EvidenceQuest)) != null)
+                {
+                    BaseCreature.TeleportPets(player, new Point3D(107, 1883, 0), Map.Malas);
+                    player.MoveToWorld(new Point3D(107, 1883, 0), Map.Malas);
+                }
+                else
+                {
+                    player.SendLocalizedMessage(1074278); // You realize that your eyes are playing tricks on you. That crate isn't really shimmering.
+                }
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+			
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/CrystalTeleporter.cs

@@ -0,0 +1,45 @@
+#region References
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using Server.Mobiles;
+using Server.Network;
+using Server.Spells;
+#endregion
+
+namespace Server.Items
+{
+    public class CrystalTeleporter : ClickTeleporter
+    {
+        public override int LabelNumber { get { return 1027961; } } // magical crystal
+
+        [Constructable]
+        public CrystalTeleporter()
+            : this(0x1F19, new Point3D(0, 0, 0), null)
+        { }
+
+        [Constructable]
+        public CrystalTeleporter(int itemID, Point3D pointDest, Map mapDest)
+            : base(itemID, pointDest, mapDest)
+        {
+        }
+
+        public CrystalTeleporter(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0); // version           
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/CustomHuePicker.cs

@@ -0,0 +1,316 @@
+using System;
+using Server.Gumps;
+using Server.Network;
+
+namespace Server.Items
+{
+    public delegate void CustomHuePickerCallback(Mobile from, object state, int hue);
+
+    public class CustomHueGroup
+    {
+        private readonly int m_Name;
+        private readonly string m_NameString;
+        private readonly int[] m_Hues;
+        private readonly int m_Item;
+        private readonly int m_ItemHues;
+
+        public CustomHueGroup(int name, int[] hues)
+        {
+            m_Name = name;
+            m_Hues = hues;
+        }
+
+        public CustomHueGroup(string name, int[] hues)
+        {
+            m_NameString = name;
+            m_Hues = hues;
+        }
+
+        public CustomHueGroup(int item, int itemhues, int[] hues)
+        {
+            m_Item = item;
+            m_ItemHues = itemhues;
+            m_Hues = hues;
+        }
+
+        public int Name { get { return m_Name; } }
+        public string NameString { get { return m_NameString; } }
+        public int[] Hues { get { return m_Hues; } }
+        public int Item { get { return m_Item; } }
+        public int ItemHues { get { return m_ItemHues; } }
+    }
+
+    public class CustomHuePicker
+    {
+        public static readonly CustomHuePicker SpecialDyeTub = new CustomHuePicker(new CustomHueGroup[]
+        {
+            /* Violet */
+            new CustomHueGroup(1018345, new int[] { 1230, 1231, 1232, 1233, 1234, 1235 }),
+            /* Tan */
+            new CustomHueGroup(1018346, new int[] { 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508 }),
+            /* Brown */
+            new CustomHueGroup(1018347, new int[] { 2012, 2013, 2014, 2015, 2016, 2017 }),
+            /* Dark Blue */
+            new CustomHueGroup(1018348, new int[] { 1303, 1304, 1305, 1306, 1307, 1308 }),
+            /* Forest Green */
+            new CustomHueGroup(1018349, new int[] { 1420, 1421, 1422, 1423, 1424, 1425, 1426 }),
+            /* Pink */
+            new CustomHueGroup(1018350, new int[] { 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626 }),
+            /* Red */
+            new CustomHueGroup(1018351, new int[] { 1640, 1641, 1642, 1643, 1644 }),
+            /* Olive */
+            new CustomHueGroup(1018352, new int[] { 2001, 2002, 2003, 2004, 2005 })
+        }, false, 1018344);
+        public static readonly CustomHuePicker LeatherDyeTub = new CustomHuePicker(new CustomHueGroup[]
+        {
+            /* Dull Copper */
+            new CustomHueGroup(1018332, new int[] { 2419, 2420, 2421, 2422, 2423, 2424 }),
+            /* Shadow Iron */
+            new CustomHueGroup(1018333, new int[] { 2406, 2407, 2408, 2409, 2410, 2411, 2412 }),
+            /* Copper */
+            new CustomHueGroup(1018334, new int[] { 2413, 2414, 2415, 2416, 2417, 2418 }),
+            /* Bronze */
+            new CustomHueGroup(1018335, new int[] { 2414, 2415, 2416, 2417, 2418 }),
+            /* Glden */
+            new CustomHueGroup(1018336, new int[] { 2213, 2214, 2215, 2216, 2217, 2218 }),
+            /* Agapite */
+            new CustomHueGroup(1018337, new int[] { 2425, 2426, 2427, 2428, 2429, 2430 }),
+            /* Verite */
+            new CustomHueGroup(1018338, new int[] { 2207, 2208, 2209, 2210, 2211, 2212 }),
+            /* Valorite */
+            new CustomHueGroup(1018339, new int[] { 2219, 2220, 2221, 2222, 2223, 2224 }),
+            /* Reds */
+            new CustomHueGroup(1018340, new int[] { 2113, 2114, 2115, 2116, 2117, 2118 }),
+            /* Blues */
+            new CustomHueGroup(1018341, new int[] { 2119, 2120, 2121, 2122, 2123, 2124 }),
+            /* Greens */
+            new CustomHueGroup(1018342, new int[] { 2126, 2127, 2128, 2129, 2130 }),
+            /* Yellows */
+            new CustomHueGroup(1018343, new int[] { 2213, 2214, 2215, 2216, 2217, 2218 })
+        }, true);
+
+        public static readonly CustomHuePicker MetallicDyeTub = new CustomHuePicker(new CustomHueGroup[]
+        {
+            
+            new CustomHueGroup(5138, 545, new int[] { 2501, 2502, 2503, 2504, 2505, 2506, 2507, 2508, 2509, 2510, 2511, 2512 }),
+            
+            new CustomHueGroup(5138, 550, new int[] { 2513, 2514, 2515, 2516, 2517, 2518, 2519, 2520, 2521, 2522, 2523, 2524 }),
+           
+            new CustomHueGroup(5138, 555, new int[] { 2525, 2526, 2527, 2528, 2529, 2530, 2531, 2532, 2533, 2534, 2535, 2536 }),
+            
+            new CustomHueGroup(5138, 560, new int[] { 2537, 2538, 2539, 2540, 2541, 2542, 2543, 2544, 2545, 2546, 2547, 2548 }),
+            
+            new CustomHueGroup(5138, 565, new int[] { 2549, 2550, 2551, 2552, 2553, 2554, 2555, 2556, 2557, 2558, 2559, 2560 }),
+            
+            new CustomHueGroup(5138, 570, new int[] { 2561, 2562, 2563, 2564, 2565, 2566, 2567, 2568, 2569, 2570, 2571, 2572 }),
+            
+            new CustomHueGroup(5138, 595, new int[] { 2573, 2574, 2575, 2576, 2577, 2578, 2579, 2580, 2581, 2582, 2583, 2584 }),
+            
+            new CustomHueGroup(5138, 601, new int[] { 2585, 2586, 2587, 2588, 2589, 2590, 2591, 2592, 2593, 2594, 2595, 2596 }),
+            
+            new CustomHueGroup(5138, 606, new int[] { 2597, 2598, 2599, 2600, 2601, 2602, 2603, 2604, 2605, 2606, 2607, 2608 }),
+            
+            new CustomHueGroup(5138, 726, new int[] { 2609, 2610, 2611, 2612, 2613, 2614, 2615, 2616, 2617, 2618, 2619, 2620 }),
+            
+            new CustomHueGroup(5138, 730, new int[] { 2621, 2622, 2623, 2624, 2625, 2626, 2627, 2628, 2629, 2630, 2631, 2632 }),
+            
+            new CustomHueGroup(5138, 735, new int[] { 2633, 2634, 2635, 2636, 2637, 2638, 2639, 2640, 2641, 2642, 2643, 2644 }),
+
+            new CustomHueGroup(5138, 805, new int[] { 2651, 2652, 2653, 2654, 2655, 2656, 2657, 2658, 2659, 2660, 2661, 2662 })
+
+        }, true);
+
+        private readonly CustomHueGroup[] m_Groups;
+        private readonly bool m_DefaultSupported;
+        private readonly int m_Title;
+        private readonly string m_TitleString;
+
+        public CustomHuePicker(CustomHueGroup[] groups, bool defaultSupported)
+        {
+            m_Groups = groups;
+            m_DefaultSupported = defaultSupported;
+        }
+
+        public CustomHuePicker(CustomHueGroup[] groups, bool defaultSupported, int title)
+        {
+            m_Groups = groups;
+            m_DefaultSupported = defaultSupported;
+            m_Title = title;
+        }
+
+        public CustomHuePicker(CustomHueGroup[] groups, bool defaultSupported, string title)
+        {
+            m_Groups = groups;
+            m_DefaultSupported = defaultSupported;
+            m_TitleString = title;
+        }
+
+        public bool DefaultSupported { get { return m_DefaultSupported; } }
+        public CustomHueGroup[] Groups { get { return m_Groups; } }
+        public int Title { get { return m_Title; } }
+        public string TitleString { get { return m_TitleString; } }
+    }
+
+    public class CustomHuePickerGump : Gump
+    {
+        private readonly Mobile m_From;
+        private readonly CustomHuePicker m_Definition;
+        private readonly CustomHuePickerCallback m_Callback;
+        private readonly object m_State;
+
+        public CustomHuePickerGump(Mobile from, CustomHuePicker definition, CustomHuePickerCallback callback, object state)
+            : base(50, 50)
+        {
+            m_From = from;
+            m_Definition = definition;
+            m_Callback = callback;
+            m_State = state;
+
+            if (definition == CustomHuePicker.MetallicDyeTub)
+            {
+                RenderMetallicBackground();
+                RenderMetallicCategories();
+            }
+            else
+            {
+                RenderBackground();
+                RenderCategories();
+            }
+        }
+
+        public override void OnResponse(NetState sender, RelayInfo info)
+        {
+            switch ( info.ButtonID )
+            {
+                case 1: // Okay
+                    {
+                        int[] switches = info.Switches;
+
+                        if (switches.Length > 0)
+                        {
+                            int index = switches[0];
+
+                            int group = index % m_Definition.Groups.Length;
+                            index /= m_Definition.Groups.Length;
+
+                            if (group >= 0 && group < m_Definition.Groups.Length)
+                            {
+                                int[] hues = m_Definition.Groups[group].Hues;
+
+                                if (index >= 0 && index < hues.Length)
+                                    m_Callback(m_From, m_State, hues[index]);
+                            }
+                        }
+
+                        break;
+                    }
+                case 2: // Default
+                    {
+                        if (m_Definition.DefaultSupported)
+                            m_Callback(m_From, m_State, 0);
+
+                        break;
+                    }
+            }
+        }
+
+        private int GetRadioID(int group, int index)
+        {
+            return (index * m_Definition.Groups.Length) + group;
+        }
+
+        private void RenderBackground()
+        {
+            AddPage(0);
+
+            AddBackground(0, 0, 450, 450, 5054);
+            AddBackground(10, 10, 430, 430, 3000);
+
+            if (m_Definition.TitleString != null)
+                AddHtml(20, 30, 400, 25, m_Definition.TitleString, false, false);
+            else if (m_Definition.Title > 0)
+                AddHtmlLocalized(20, 30, 400, 25, m_Definition.Title, false, false);
+
+            AddButton(20, 400, 4005, 4007, 1, GumpButtonType.Reply, 0);
+            AddHtmlLocalized(55, 400, 200, 25, 1011036, false, false); // OKAY
+
+            if (m_Definition.DefaultSupported)
+            {
+                AddButton(200, 400, 4005, 4007, 2, GumpButtonType.Reply, 0);
+                AddLabel(235, 400, 0, "DEFAULT");
+            }
+        }        
+
+        private void RenderCategories()
+        {
+            CustomHueGroup[] groups = m_Definition.Groups;
+
+            for (int i = 0; i < groups.Length; ++i)
+            {
+                AddButton(30, 85 + (i * 25), 5224, 5224, 0, GumpButtonType.Page, 1 + i);
+
+                if (groups[i].NameString != null)
+                    AddHtml(55, 85 + (i * 25), 200, 25, groups[i].NameString, false, false);
+                else
+                    AddHtmlLocalized(55, 85 + (i * 25), 200, 25, groups[i].Name, false, false);
+            }
+
+            for (int i = 0; i < groups.Length; ++i)
+            {
+                AddPage(1 + i);
+
+                int[] hues = groups[i].Hues;
+
+                for (int j = 0; j < hues.Length; ++j)
+                {
+                    AddRadio(260, 90 + (j * 25), 210, 211, false, GetRadioID(i, j));
+                    AddLabel(278, 90 + (j * 25), hues[j] - 1, "*****");
+                }
+            }
+        }
+
+        private void RenderMetallicBackground()
+        {
+            AddPage(0);
+
+            AddBackground(0, 0, 450, 450, 5054);
+            AddBackground(10, 10, 430, 430, 3000);
+
+            AddHtmlLocalized(60, 20, 400, 25, 1150063, false, false); // Base/Shadow Color
+            AddHtmlLocalized(260, 20, 400, 25, 1150064, false, false); // Highlight Color
+
+            AddButton(20, 400, 4005, 4007, 1, GumpButtonType.Reply, 0);
+            AddHtmlLocalized(55, 400, 200, 25, 1011036, false, false); // OKAY
+
+            if (m_Definition.DefaultSupported)
+            {
+                AddButton(200, 400, 4005, 4007, 2, GumpButtonType.Reply, 0);
+                AddLabel(235, 400, 0, "DEFAULT");
+            }
+        }
+
+        private void RenderMetallicCategories()
+        {
+            CustomHueGroup[] groups = m_Definition.Groups;
+
+            for (int i = 0; i < groups.Length; ++i)
+            {
+                AddButton(30, 65 + (i * 25), 5224, 5224, 0, GumpButtonType.Page, 1 + i);
+                AddItem(55, 65 + (i * 25), groups[i].Item, groups[i].ItemHues);
+            }
+
+            for (int i = 0; i < groups.Length; ++i)
+            {
+                AddPage(1 + i);
+
+                int[] hues = groups[i].Hues;
+
+                for (int j = 0; j < hues.Length; ++j)
+                {
+                    AddRadio(260, 70 + (j * 25), 210, 211, false, GetRadioID(i, j));
+                    AddItem(278, 70 + (j * 25), 5138, hues[j]);
+                }
+            }
+        }
+    }
+}

Scripts/Items/Internal/DespiseTeleporter.cs

@@ -0,0 +1,347 @@
+using Server;
+using System;
+using Server.Mobiles;
+using Server.Engines.Despise;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Server.Items
+{
+    public class DespiseTeleporter : Teleporter
+    {
+        [Constructable]
+        public DespiseTeleporter()
+        {
+        }
+
+        public override bool CanTeleport(Mobile m)
+        {
+            if (m is DespiseCreature)
+                return false;
+
+            return base.CanTeleport(m);
+        }
+
+        public override void DoTeleport(Mobile m)
+        {
+            Map map = MapDest;
+
+            if (map == null || map == Map.Internal)
+                map = m.Map;
+
+            Point3D p = PointDest;
+
+            if (p == Point3D.Zero)
+                p = m.Location;
+
+            TeleportPets(m, p, map);
+
+            bool sendEffect = (!m.Hidden || m.AccessLevel == AccessLevel.Player);
+
+            if (SourceEffect && sendEffect)
+                Effects.SendLocationEffect(m.Location, m.Map, 0x3728, 10, 10);
+
+            m.MoveToWorld(p, map);
+
+            if (DestEffect && sendEffect)
+                Effects.SendLocationEffect(m.Location, m.Map, 0x3728, 10, 10);
+
+            if (SoundID > 0 && sendEffect)
+                Effects.PlaySound(m.Location, m.Map, SoundID);
+        }
+
+        public static void TeleportPets(Mobile master, Point3D loc, Map map)
+        {
+            var move = new List<Mobile>();
+            IPooledEnumerable eable = master.GetMobilesInRange(3);
+
+            foreach (Mobile m in eable)
+            {
+                if (m is BaseCreature && !(m is DespiseCreature))
+                {
+                    BaseCreature pet = (BaseCreature)m;
+
+                    if (pet.Controlled && pet.ControlMaster == master)
+                    {
+                        if (pet.ControlOrder == OrderType.Guard || pet.ControlOrder == OrderType.Follow ||
+                            pet.ControlOrder == OrderType.Come)
+                        {
+                            move.Add(pet);
+                        }
+                    }
+                }
+            }
+
+            eable.Free();
+
+            foreach (Mobile m in move)
+            {
+                m.MoveToWorld(loc, map);
+            }
+
+            move.Clear();
+            move.TrimExcess();
+        }
+
+        public DespiseTeleporter(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write((int)0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int v = reader.ReadInt();
+		}
+    }
+
+    public class GateTeleporter : Item
+    {
+        private Point3D _Destination;
+        private Map _DestinationMap;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Point3D Destination
+        {
+            get { return _Destination; }
+            set
+            {
+                if (_Destination != value)
+                {
+                    _Destination = value;
+                    AssignDestination(value);
+                }
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Map DestinationMap
+        {
+            get { return _DestinationMap; }
+            set
+            {
+                if (DestinationMap != value)
+                {
+                    _DestinationMap = value;
+                    AssignMap(value);
+                }
+            }
+        }
+
+        public List<InternalTeleporter> Teleporters { get; set; }
+
+        [Constructable]
+        public GateTeleporter()
+            : this(19343, 0, Point3D.Zero, null)
+        {
+        }
+
+        public GateTeleporter(int id, int hue, Point3D destination, Map destinationMap)
+            : base(id)
+        {
+            Hue = hue;
+
+            Movable = false;
+
+            _Destination = destination;
+            _DestinationMap = destinationMap;
+
+            AssignTeleporters();
+        }
+
+        private void AssignTeleporters()
+        {
+            if (Teleporters != null)
+            {
+                foreach (var tele in Teleporters.Where(t => t != null && !t.Deleted))
+                {
+                    tele.Delete();
+                }
+
+                ColUtility.Free(Teleporters);
+            }
+
+            Teleporters = new List<InternalTeleporter>();
+
+            for (int i = 0; i <= 7; i++)
+            {
+                Direction offset = (Direction)i;
+
+                var tele = new InternalTeleporter(this, _Destination, _DestinationMap);
+
+                int x = this.X;
+                int y = this.Y;
+                int z = this.Z;
+
+                Movement.Movement.Offset(offset, ref x, ref y);
+                tele.MoveToWorld(new Point3D(x, y, z), this.Map);
+
+                Teleporters.Add(tele);
+            }
+        }
+
+        public void AssignDestination(Point3D p)
+        {
+            if (Teleporters == null)
+            {
+                AssignTeleporters();
+            }
+            else
+            {
+                Teleporters.ForEach(t => t.PointDest = p);
+            }
+        }
+
+        public void AssignMap(Map map)
+        {
+            if (Teleporters == null)
+            {
+                AssignTeleporters();
+            }
+            else
+            {
+                Teleporters.ForEach(t => t.MapDest = map);
+            }
+        }
+
+        public override void OnMapChange()
+        {
+            if (Teleporters != null)
+            {
+                Teleporters.ForEach(t => t.Map = Map);
+            }
+        }
+
+        public override void OnLocationChange(Point3D old)
+        {
+            if (Teleporters != null)
+            {
+                Teleporters.ForEach(t =>
+                    {
+                        t.Location = new Point3D(X + (t.X - old.X), Y + (t.Y - old.Y), Z + (t.Z - old.Z));
+                    });
+            }
+        }
+
+        public override void Delete()
+        {
+            base.Delete();
+
+            if (Teleporters != null)
+            {
+                Teleporters.ForEach(t => t.Delete());
+
+                ColUtility.Free(Teleporters);
+            }
+        }
+
+        public GateTeleporter(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write((int)0);
+
+            writer.Write(_Destination);
+            writer.Write(_DestinationMap);
+
+            writer.Write(Teleporters == null ? 0 : Teleporters.Count);
+
+            if (Teleporters != null)
+            {
+                Teleporters.ForEach(t => writer.Write(t));
+            }
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int v = reader.ReadInt();
+
+            _Destination = reader.ReadPoint3D();
+            _DestinationMap = reader.ReadMap();
+
+            int count = reader.ReadInt();
+            for (int i = 0; i < count; i++)
+            {
+                if (Teleporters == null)
+                    Teleporters = new List<InternalTeleporter>();
+
+                var tele = reader.ReadItem() as InternalTeleporter;
+
+                if (tele != null)
+                {
+                    Teleporters.Add(tele);
+                    tele.Master = this;
+                }
+            }
+		}
+
+        public class InternalTeleporter : Teleporter
+        {
+            [CommandProperty(AccessLevel.GameMaster)]
+            public GateTeleporter Master { get; set; }
+
+            public InternalTeleporter(GateTeleporter master, Point3D dest, Map destMap)
+                : base(dest, destMap, true)
+            {
+                Master = master;
+            }
+
+            public override bool OnMoveOver(Mobile m)
+            {
+                return true;
+            }
+
+            public override bool HandlesOnMovement { get { return Master != null && Utility.InRange(Master.Location, Location, 1) && this.Map == Master.Map; } }
+            
+            public override void OnMovement(Mobile m, Point3D oldLocation)
+            {
+                if (Master == null || Master.Destination == Point3D.Zero || Master.Map == null || Master.Map == Map.Internal)
+                    return;
+
+                if (m.Location == Location)
+                {
+                    var eable = Map.GetItemsInRange(oldLocation, 0);
+
+                    foreach (Item item in eable)
+                    {
+                        if (item is InternalTeleporter || item == Master)
+                        {
+                            eable.Free();
+                            return;
+                        }
+                    }
+
+                    base.OnMoveOver(m);
+                }
+            }
+
+            public InternalTeleporter(Serial serial)
+                : base(serial)
+            {
+            }
+
+            public override void Serialize(GenericWriter writer)
+            {
+                base.Serialize(writer);
+                writer.Write((int)0);
+            }
+
+            public override void Deserialize(GenericReader reader)
+            {
+                base.Deserialize(reader);
+                int v = reader.ReadInt();
+            }
+        }
+    }
+}

Scripts/Items/Internal/EffectController.cs

@@ -0,0 +1,577 @@
+using System;
+
+namespace Server.Items
+{
+    public enum ECEffectType
+    {
+        None,
+        Moving,
+        Location,
+        Target,
+        Lightning
+    }
+
+    public enum EffectTriggerType
+    {
+        None,
+        Sequenced,
+        DoubleClick,
+        InRange
+    }
+
+    public class EffectController : Item
+    {
+        private TimeSpan m_EffectDelay;
+        private ECEffectType m_EffectType;
+        private EffectTriggerType m_TriggerType;
+        private IEntity m_Source;
+        private IEntity m_Target;
+        private TimeSpan m_TriggerDelay;
+        private EffectController m_Trigger;
+        private int m_ItemID;
+        private int m_Hue;
+        private int m_RenderMode;
+        private int m_Speed;
+        private int m_Duration;
+        private bool m_FixedDirection;
+        private bool m_Explodes;
+        private int m_ParticleEffect;
+        private int m_ExplodeParticleEffect;
+        private int m_ExplodeSound;
+        private EffectLayer m_EffectLayer;
+        private int m_Unknown;
+        private TimeSpan m_SoundDelay;
+        private int m_SoundID;
+        private bool m_PlaySoundAtTrigger;
+        private int m_TriggerRange;
+        [Constructable]
+        public EffectController()
+            : base(0x1B72)
+        {
+            this.Movable = false;
+            this.Visible = false;
+            this.m_TriggerType = EffectTriggerType.Sequenced;
+            this.m_EffectLayer = (EffectLayer)255;
+        }
+
+        public EffectController(Serial serial)
+            : base(serial)
+        {
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public ECEffectType EffectType
+        {
+            get
+            {
+                return this.m_EffectType;
+            }
+            set
+            {
+                this.m_EffectType = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public EffectTriggerType TriggerType
+        {
+            get
+            {
+                return this.m_TriggerType;
+            }
+            set
+            {
+                this.m_TriggerType = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public EffectLayer EffectLayer
+        {
+            get
+            {
+                return this.m_EffectLayer;
+            }
+            set
+            {
+                this.m_EffectLayer = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public TimeSpan EffectDelay
+        {
+            get
+            {
+                return this.m_EffectDelay;
+            }
+            set
+            {
+                this.m_EffectDelay = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public TimeSpan TriggerDelay
+        {
+            get
+            {
+                return this.m_TriggerDelay;
+            }
+            set
+            {
+                this.m_TriggerDelay = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public TimeSpan SoundDelay
+        {
+            get
+            {
+                return this.m_SoundDelay;
+            }
+            set
+            {
+                this.m_SoundDelay = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Item SourceItem
+        {
+            get
+            {
+                return this.m_Source as Item;
+            }
+            set
+            {
+                this.m_Source = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Mobile SourceMobile
+        {
+            get
+            {
+                return this.m_Source as Mobile;
+            }
+            set
+            {
+                this.m_Source = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool SourceNull
+        {
+            get
+            {
+                return (this.m_Source == null);
+            }
+            set
+            {
+                if (value)
+                    this.m_Source = null;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Item TargetItem
+        {
+            get
+            {
+                return this.m_Target as Item;
+            }
+            set
+            {
+                this.m_Target = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Mobile TargetMobile
+        {
+            get
+            {
+                return this.m_Target as Mobile;
+            }
+            set
+            {
+                this.m_Target = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool TargetNull
+        {
+            get
+            {
+                return (this.m_Target == null);
+            }
+            set
+            {
+                if (value)
+                    this.m_Target = null;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public EffectController Sequence
+        {
+            get
+            {
+                return this.m_Trigger;
+            }
+            set
+            {
+                this.m_Trigger = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int EffectItemID
+        {
+            get
+            {
+                return this.m_ItemID;
+            }
+            set
+            {
+                this.m_ItemID = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int EffectHue
+        {
+            get
+            {
+                return this.m_Hue;
+            }
+            set
+            {
+                this.m_Hue = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int RenderMode
+        {
+            get
+            {
+                return this.m_RenderMode;
+            }
+            set
+            {
+                this.m_RenderMode = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int Speed
+        {
+            get
+            {
+                return this.m_Speed;
+            }
+            set
+            {
+                this.m_Speed = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int Duration
+        {
+            get
+            {
+                return this.m_Duration;
+            }
+            set
+            {
+                this.m_Duration = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int ParticleEffect
+        {
+            get
+            {
+                return this.m_ParticleEffect;
+            }
+            set
+            {
+                this.m_ParticleEffect = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int ExplodeParticleEffect
+        {
+            get
+            {
+                return this.m_ExplodeParticleEffect;
+            }
+            set
+            {
+                this.m_ExplodeParticleEffect = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int ExplodeSound
+        {
+            get
+            {
+                return this.m_ExplodeSound;
+            }
+            set
+            {
+                this.m_ExplodeSound = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int Unknown
+        {
+            get
+            {
+                return this.m_Unknown;
+            }
+            set
+            {
+                this.m_Unknown = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int SoundID
+        {
+            get
+            {
+                return this.m_SoundID;
+            }
+            set
+            {
+                this.m_SoundID = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int TriggerRange
+        {
+            get
+            {
+                return this.m_TriggerRange;
+            }
+            set
+            {
+                this.m_TriggerRange = value;
+            }
+        }
+        public override string DefaultName
+        {
+            get
+            {
+                return "Effect Controller";
+            }
+        }
+        public override bool HandlesOnMovement
+        {
+            get
+            {
+                return (this.m_TriggerType == EffectTriggerType.InRange);
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        private bool FixedDirection
+        {
+            get
+            {
+                return this.m_FixedDirection;
+            }
+            set
+            {
+                this.m_FixedDirection = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        private bool Explodes
+        {
+            get
+            {
+                return this.m_Explodes;
+            }
+            set
+            {
+                this.m_Explodes = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        private bool PlaySoundAtTrigger
+        {
+            get
+            {
+                return this.m_PlaySoundAtTrigger;
+            }
+            set
+            {
+                this.m_PlaySoundAtTrigger = value;
+            }
+        }
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (this.m_TriggerType == EffectTriggerType.DoubleClick)
+                this.DoEffect(from);
+        }
+
+        public override void OnMovement(Mobile m, Point3D oldLocation)
+        {
+            if (m.Location != oldLocation && this.m_TriggerType == EffectTriggerType.InRange && Utility.InRange(this.GetWorldLocation(), m.Location, this.m_TriggerRange) && !Utility.InRange(this.GetWorldLocation(), oldLocation, this.m_TriggerRange))
+                this.DoEffect(m);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+
+            writer.Write(this.m_EffectDelay);
+            writer.Write(this.m_TriggerDelay);
+            writer.Write(this.m_SoundDelay);
+
+            if (this.m_Source is Item)
+                writer.Write(this.m_Source as Item);
+            else
+                writer.Write(this.m_Source as Mobile);
+
+            if (this.m_Target is Item)
+                writer.Write(this.m_Target as Item);
+            else
+                writer.Write(this.m_Target as Mobile);
+
+            writer.Write(this.m_Trigger as Item);
+
+            writer.Write(this.m_FixedDirection);
+            writer.Write(this.m_Explodes);
+            writer.Write(this.m_PlaySoundAtTrigger);
+
+            writer.WriteEncodedInt((int)this.m_EffectType);
+            writer.WriteEncodedInt((int)this.m_EffectLayer);
+            writer.WriteEncodedInt((int)this.m_TriggerType);
+
+            writer.WriteEncodedInt(this.m_ItemID);
+            writer.WriteEncodedInt(this.m_Hue);
+            writer.WriteEncodedInt(this.m_RenderMode);
+            writer.WriteEncodedInt(this.m_Speed);
+            writer.WriteEncodedInt(this.m_Duration);
+            writer.WriteEncodedInt(this.m_ParticleEffect);
+            writer.WriteEncodedInt(this.m_ExplodeParticleEffect);
+            writer.WriteEncodedInt(this.m_ExplodeSound);
+            writer.WriteEncodedInt(this.m_Unknown);
+            writer.WriteEncodedInt(this.m_SoundID);
+            writer.WriteEncodedInt(this.m_TriggerRange);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 0:
+                    {
+                        this.m_EffectDelay = reader.ReadTimeSpan();
+                        this.m_TriggerDelay = reader.ReadTimeSpan();
+                        this.m_SoundDelay = reader.ReadTimeSpan();
+
+                        this.m_Source = this.ReadEntity(reader);
+                        this.m_Target = this.ReadEntity(reader);
+                        this.m_Trigger = reader.ReadItem() as EffectController;
+
+                        this.m_FixedDirection = reader.ReadBool();
+                        this.m_Explodes = reader.ReadBool();
+                        this.m_PlaySoundAtTrigger = reader.ReadBool();
+
+                        this.m_EffectType = (ECEffectType)reader.ReadEncodedInt();
+                        this.m_EffectLayer = (EffectLayer)reader.ReadEncodedInt();
+                        this.m_TriggerType = (EffectTriggerType)reader.ReadEncodedInt();
+
+                        this.m_ItemID = reader.ReadEncodedInt();
+                        this.m_Hue = reader.ReadEncodedInt();
+                        this.m_RenderMode = reader.ReadEncodedInt();
+                        this.m_Speed = reader.ReadEncodedInt();
+                        this.m_Duration = reader.ReadEncodedInt();
+                        this.m_ParticleEffect = reader.ReadEncodedInt();
+                        this.m_ExplodeParticleEffect = reader.ReadEncodedInt();
+                        this.m_ExplodeSound = reader.ReadEncodedInt();
+                        this.m_Unknown = reader.ReadEncodedInt();
+                        this.m_SoundID = reader.ReadEncodedInt();
+                        this.m_TriggerRange = reader.ReadEncodedInt();
+
+                        break;
+                    }
+            }
+        }
+
+        public void PlaySound(object trigger)
+        {
+            IEntity ent = null;
+
+            if (this.m_PlaySoundAtTrigger)
+                ent = trigger as IEntity;
+
+            if (ent == null)
+                ent = this;
+
+            Effects.PlaySound((ent is Item) ? ((Item)ent).GetWorldLocation() : ent.Location, ent.Map, this.m_SoundID);
+        }
+
+        public void DoEffect(object trigger)
+        {
+            if (this.Deleted || this.m_TriggerType == EffectTriggerType.None)
+                return;
+
+            if (trigger is Mobile && ((Mobile)trigger).Hidden && ((Mobile)trigger).IsStaff())
+                return;
+
+            if (this.m_SoundID > 0)
+                Timer.DelayCall(this.m_SoundDelay, new TimerStateCallback(PlaySound), trigger);
+
+            if (this.m_Trigger != null)
+                Timer.DelayCall(this.m_TriggerDelay, new TimerStateCallback(this.m_Trigger.DoEffect), trigger);
+
+            if (this.m_EffectType != ECEffectType.None)
+                Timer.DelayCall(this.m_EffectDelay, new TimerStateCallback(InternalDoEffect), trigger);
+        }
+
+        public void InternalDoEffect(object trigger)
+        {
+            IEntity from = this.m_Source, to = this.m_Target;
+			
+            if (from == null)
+                from = (IEntity)trigger;
+
+            if (to == null)
+                to = (IEntity)trigger;
+
+            switch ( this.m_EffectType )
+            {
+                case ECEffectType.Lightning:
+                    {
+                        Effects.SendBoltEffect(from, false, this.m_Hue);
+                        break;
+                    }
+                case ECEffectType.Location:
+                    {
+                        Effects.SendLocationParticles(EffectItem.Create(from.Location, from.Map, EffectItem.DefaultDuration), this.m_ItemID, this.m_Speed, this.m_Duration, this.m_Hue, this.m_RenderMode, this.m_ParticleEffect, this.m_Unknown);
+                        break;
+                    }
+                case ECEffectType.Moving:
+                    {
+                        if (from == this)
+                            from = EffectItem.Create(from.Location, from.Map, EffectItem.DefaultDuration);
+
+                        if (to == this)
+                            to = EffectItem.Create(to.Location, to.Map, EffectItem.DefaultDuration);
+
+                        Effects.SendMovingParticles(from, to, this.m_ItemID, this.m_Speed, this.m_Duration, this.m_FixedDirection, this.m_Explodes, this.m_Hue, this.m_RenderMode, this.m_ParticleEffect, this.m_ExplodeParticleEffect, this.m_ExplodeSound, this.m_EffectLayer, this.m_Unknown);
+                        break;
+                    }
+                case ECEffectType.Target:
+                    {
+                        Effects.SendTargetParticles(from, this.m_ItemID, this.m_Speed, this.m_Duration, this.m_Hue, this.m_RenderMode, this.m_ParticleEffect, this.m_EffectLayer, this.m_Unknown);
+                        break;
+                    }
+            }
+        }
+
+        private IEntity ReadEntity(GenericReader reader)
+        {
+            return World.FindEntity(reader.ReadInt());
+        }
+    }
+}

Scripts/Items/Internal/EffectItem.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+
+namespace Server.Items
+{
+    public class EffectItem : Item
+    {
+        public static readonly TimeSpan DefaultDuration = TimeSpan.FromSeconds(5.0);
+        private static readonly List<EffectItem> m_Free = new List<EffectItem>();// List of available EffectItems
+        public EffectItem(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private EffectItem()
+            : base(1)// nodraw
+        {
+            this.Movable = false;
+        }
+
+        public override bool Decays
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public static EffectItem Create(Point3D p, Map map, TimeSpan duration)
+        {
+            EffectItem item = null;
+
+            for (int i = m_Free.Count - 1; item == null && i >= 0; --i) // We reuse new entries first so decay works better
+            {
+                EffectItem free = m_Free[i];
+
+                m_Free.RemoveAt(i);
+
+                if (!free.Deleted && free.Map == Map.Internal)
+                    item = free;
+            }
+
+            if (item == null)
+                item = new EffectItem();
+            else
+                item.ItemID = 1;
+
+            item.MoveToWorld(p, map);
+            item.BeginFree(duration);
+
+            return item;
+        }
+
+        public void BeginFree(TimeSpan duration)
+        {
+            new FreeTimer(this, duration).Start();
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            this.Delete();
+        }
+
+        private class FreeTimer : Timer
+        {
+            private readonly EffectItem m_Item;
+            public FreeTimer(EffectItem item, TimeSpan delay)
+                : base(delay)
+            {
+                this.m_Item = item;
+                this.Priority = TimerPriority.OneSecond;
+            }
+
+            protected override void OnTick()
+            {
+                this.m_Item.Internalize();
+
+                m_Free.Add(this.m_Item);
+            }
+        }
+    }
+}

Scripts/Items/Internal/EffectMobile.cs

@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+
+namespace Server.Mobiles
+{
+    public class EffectMobile : Mobile
+    {
+        public static readonly TimeSpan DefaultDuration = TimeSpan.FromSeconds(1.0);
+        private static readonly List<EffectMobile> m_Free = new List<EffectMobile>();// List of available EffectMobiles
+
+        public EffectMobile(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private EffectMobile()
+        {
+            CantWalk = true;
+            Hidden = true;
+        }
+
+        public static EffectMobile Create(Point3D p, Map map, TimeSpan duration)
+        {
+            EffectMobile mobile = null;
+
+            for (int i = m_Free.Count - 1; mobile == null && i >= 0; --i) // We reuse new entries first so decay works better
+            {
+                EffectMobile free = m_Free[i];
+
+                m_Free.RemoveAt(i);
+
+                if (!free.Deleted && free.Map == Map.Internal)
+                    mobile = free;
+            }
+
+            if (mobile == null)
+                mobile = new EffectMobile();
+
+            mobile.MoveToWorld(p, map);
+            mobile.BeginFree(duration);
+
+            return mobile;
+        }
+
+        public void BeginFree(TimeSpan duration)
+        {
+            new FreeTimer(this, duration).Start();
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            Delete();
+        }
+
+        private class FreeTimer : Timer
+        {
+            private readonly EffectMobile m_Mobile;
+            public FreeTimer(EffectMobile mobile, TimeSpan delay)
+                : base(delay)
+            {
+                m_Mobile = mobile;
+                Priority = TimerPriority.OneSecond;
+            }
+
+            protected override void OnTick()
+            {
+                m_Mobile.Internalize();
+
+                m_Free.Add(m_Mobile);
+            }
+        }
+    }
+}

Scripts/Items/Internal/FlipableAddonAttribute.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Reflection;
+using Server.Multis;
+
+namespace Server.Items
+{
+    [AttributeUsage(AttributeTargets.Class)]
+    public class FlipableAddonAttribute : Attribute
+    {
+        private static readonly string m_MethodName = "Flip";
+        private static readonly Type[] m_Params = new Type[]
+        {
+            typeof(Mobile), typeof(Direction)
+        };
+        private readonly Direction[] m_Directions;
+        public FlipableAddonAttribute(params Direction[] directions)
+        {
+            this.m_Directions = directions;
+        }
+
+        public Direction[] Directions
+        {
+            get
+            {
+                return this.m_Directions;
+            }
+        }
+        public virtual void Flip(Mobile from, Item addon)
+        {
+            if (this.m_Directions != null && this.m_Directions.Length > 1)
+            {
+                try
+                {
+                    MethodInfo flipMethod = addon.GetType().GetMethod(m_MethodName, m_Params);
+
+                    if (flipMethod != null)
+                    {
+                        int index = 0;
+
+                        for (int i = 0; i < this.m_Directions.Length; i++)
+                        {
+                            if (addon.Direction == this.m_Directions[i])
+                            {
+                                index = i + 1;
+                                break;
+                            }
+                        }
+
+                        if (index >= this.m_Directions.Length)
+                            index = 0;
+
+                        this.ClearComponents(addon);
+
+                        flipMethod.Invoke(addon, new object[2] { from, this.m_Directions[index] });
+
+                        BaseHouse house = null;
+                        AddonFitResult result = AddonFitResult.Valid;
+
+                        addon.Map = Map.Internal;
+
+                        if (addon is BaseAddon)
+                            result = ((BaseAddon)addon).CouldFit(addon.Location, from.Map, from, ref house);
+                        else if (addon is BaseAddonContainer)
+                            result = ((BaseAddonContainer)addon).CouldFit(addon.Location, from.Map, from, ref house);
+
+                        addon.Map = from.Map;
+
+                        if (result != AddonFitResult.Valid)
+                        {
+                            if (index == 0)
+                                index = this.m_Directions.Length - 1;
+                            else
+                                index -= 1;
+
+                            this.ClearComponents(addon);
+
+                            flipMethod.Invoke(addon, new object[2] { from, this.m_Directions[index] });
+
+                            if (result == AddonFitResult.Blocked)
+                                from.SendLocalizedMessage(500269); // You cannot build that there.
+                            else if (result == AddonFitResult.NotInHouse)
+                                from.SendLocalizedMessage(500274); // You can only place this in a house that you own!
+                            else if (result == AddonFitResult.DoorsNotClosed)
+                                from.SendMessage("You must close all house doors before placing this.");
+                            else if (result == AddonFitResult.DoorTooClose)
+                                from.SendLocalizedMessage(500271); // You cannot build near the door.
+                            else if (result == AddonFitResult.NoWall)
+                                from.SendLocalizedMessage(500268); // This object needs to be mounted on something.
+                        }
+
+                        addon.Direction = this.m_Directions[index];
+                    }
+                }
+                catch
+                {
+                }
+            }
+        }
+
+        private void ClearComponents(Item item)
+        {
+            if (item is BaseAddon)
+            {
+                BaseAddon addon = (BaseAddon)item;
+
+                foreach (AddonComponent c in addon.Components)
+                {
+                    c.Addon = null;
+                    c.Delete();
+                }
+
+                addon.Components.Clear();
+            }
+            else if (item is BaseAddonContainer)
+            {
+                BaseAddonContainer addon = (BaseAddonContainer)item;
+
+                foreach (AddonContainerComponent c in addon.Components)
+                {
+                    c.Addon = null;
+                    c.Delete();
+                }
+
+                addon.Components.Clear();
+            }
+        }
+    }
+}

Scripts/Items/Internal/FlipableAttribute.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Reflection;
+using Server.Commands;
+using Server.Targeting;
+
+namespace Server.Items
+{
+    public class FlipCommandHandlers
+    {
+        public static void Initialize()
+        {
+            CommandSystem.Register("Flip", AccessLevel.GameMaster, new CommandEventHandler(Flip_OnCommand));
+        }
+
+        [Usage("Flip")]
+        [Description("Turns an item.")]
+        public static void Flip_OnCommand(CommandEventArgs e)
+        {
+            e.Mobile.Target = new FlipTarget();
+        }
+
+        private class FlipTarget : Target
+        {
+            public FlipTarget()
+                : base(-1, false, TargetFlags.None)
+            {
+            }
+
+            protected override void OnTarget(Mobile from, object targeted)
+            {
+                if (targeted is Item)
+                {
+                    Item item = (Item)targeted;
+
+                    if (item.Movable == false && from.IsPlayer())
+                        return;
+
+                    Type type = targeted.GetType();
+
+                    FlipableAttribute[] AttributeArray = (FlipableAttribute[])type.GetCustomAttributes(typeof(FlipableAttribute), false);
+
+                    if (AttributeArray.Length == 0)
+                    {
+                        return;
+                    }
+
+                    FlipableAttribute fa = AttributeArray[0];
+
+                    fa.Flip((Item)targeted);
+                }
+            }
+        }
+    }
+
+    [AttributeUsage(AttributeTargets.Class)]
+    public class DynamicFlipingAttribute : Attribute
+    {
+        public DynamicFlipingAttribute()
+        {
+        }
+    }
+
+    [AttributeUsage(AttributeTargets.Class)]
+    public class FlipableAttribute : Attribute
+    {
+        private readonly int[] m_ItemIDs;
+        public FlipableAttribute()
+            : this(null)
+        {
+        }
+
+        public FlipableAttribute(params int[] itemIDs)
+        {
+            this.m_ItemIDs = itemIDs;
+        }
+
+        public int[] ItemIDs
+        {
+            get
+            {
+                return this.m_ItemIDs;
+            }
+        }
+        public virtual void Flip(Item item)
+        {
+            if (this.m_ItemIDs == null)
+            {
+                try
+                {
+                    MethodInfo flipMethod = item.GetType().GetMethod("Flip", Type.EmptyTypes);
+                    if (flipMethod != null)
+                        flipMethod.Invoke(item, new object[0]);
+                }
+                catch
+                {
+                }
+            }
+            else
+            {
+                int index = 0;
+                for (int i = 0; i < this.m_ItemIDs.Length; i++)
+                {
+                    if (item.ItemID == this.m_ItemIDs[i])
+                    {
+                        index = i + 1;
+                        break;
+                    }
+                }
+
+                if (index > this.m_ItemIDs.Length - 1)
+                    index = 0;
+
+                item.ItemID = this.m_ItemIDs[index];
+            }
+        }
+    }
+}

Scripts/Items/Internal/GreenNinjaQuestTeleporter.cs

@@ -0,0 +1,62 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Engines.Quests.Ninja
+{
+    public class GreenNinjaQuestTeleporter : DynamicTeleporter
+    {
+        [Constructable]
+        public GreenNinjaQuestTeleporter()
+            : base(0x51C, 0x17E)
+        {
+        }
+
+        public GreenNinjaQuestTeleporter(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1026157;
+            }
+        }// teleporter
+        public override int NotWorkingMessage
+        {
+            get
+            {
+                return 1063198;
+            }
+        }// You stand on the strange floor tile but nothing happens.
+        public override bool GetDestination(PlayerMobile player, ref Point3D loc, ref Map map)
+        {
+            QuestSystem qs = player.Quest;
+
+            if (qs is EminosUndertakingQuest && qs.FindObjective(typeof(UseTeleporterObjective)) != null)
+            {
+                loc = new Point3D(410, 1125, 0);
+                map = Map.Malas;
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/GuildTeleporter.cs

@@ -0,0 +1,114 @@
+using System;
+using Server.Guilds;
+using Server.Multis;
+
+namespace Server.Items
+{
+    public class GuildTeleporter : Item
+    {
+        private Item m_Stone;
+        [Constructable]
+        public GuildTeleporter()
+            : this(null)
+        {
+        }
+
+        public GuildTeleporter(Item stone)
+            : base(0x1869)
+        {
+            this.Weight = 1.0;
+            this.LootType = LootType.Blessed;
+
+            this.m_Stone = stone;
+        }
+
+        public GuildTeleporter(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1041054;
+            }
+        }// guildstone teleporter
+        public override bool DisplayLootType
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+
+            writer.Write(this.m_Stone);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            this.LootType = LootType.Blessed;
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 0:
+                    {
+                        this.m_Stone = reader.ReadItem();
+
+                        break;
+                    }
+            }
+
+            if (this.Weight == 0.0)
+                this.Weight = 1.0;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (Guild.NewGuildSystem)
+                return;
+
+            Guildstone stone = this.m_Stone as Guildstone;
+
+            if (!this.IsChildOf(from.Backpack))
+            {
+                from.SendLocalizedMessage(1042001); // That must be in your pack for you to use it.
+            }
+            else if (stone == null || stone.Deleted || stone.Guild == null || stone.Guild.Teleporter != this)
+            {
+                from.SendLocalizedMessage(501197); // This teleporting object can not determine what guildstone to teleport
+            }
+            else
+            {
+                BaseHouse house = BaseHouse.FindHouseAt(from);
+
+                if (house == null)
+                {
+                    from.SendLocalizedMessage(501138); // You can only place a guildstone in a house.
+                }
+                else if (!house.IsOwner(from))
+                {
+                    from.SendLocalizedMessage(501141); // You can only place a guildstone in a house you own!
+                }
+                else if (house.FindGuildstone() != null)
+                {
+                    from.SendLocalizedMessage(501142);//Only one guildstone may reside in a given house.
+                }
+                else
+                {
+                    this.m_Stone.MoveToWorld(from.Location, from.Map);
+                    this.Delete();
+                    stone.Guild.Teleporter = null;
+                }
+            }
+        }
+    }
+}

Scripts/Items/Internal/Hair.cs

@@ -0,0 +1,468 @@
+using System;
+
+namespace Server.Items
+{
+    public abstract class Hair : Item
+    {
+        public Hair(Serial serial)
+            : base(serial)
+        {
+        }
+
+        /*
+        public static Hair GetRandomHair( bool female )
+        {
+        return GetRandomHair( female, Utility.RandomHairHue() );
+        }
+        public static Hair GetRandomHair( bool female, int hairHue )
+        {
+        if( female )
+        {
+        switch ( Utility.Random( 9 ) )
+        {
+        case 0: return new Afro( hairHue );
+        case 1: return new KrisnaHair( hairHue );
+        case 2: return new PageboyHair( hairHue );
+        case 3: return new PonyTail( hairHue );
+        case 4: return new ReceedingHair( hairHue );
+        case 5: return new TwoPigTails( hairHue );
+        case 6: return new ShortHair( hairHue );
+        case 7: return new LongHair( hairHue );
+        default: return new BunsHair( hairHue );
+        }
+        }
+        else
+        {
+        switch ( Utility.Random( 8 ) )
+        {
+        case 0: return new Afro( hairHue );
+        case 1: return new KrisnaHair( hairHue );
+        case 2: return new PageboyHair( hairHue );
+        case 3: return new PonyTail( hairHue );
+        case 4: return new ReceedingHair( hairHue );
+        case 5: return new TwoPigTails( hairHue );
+        case 6: return new ShortHair( hairHue );
+        default: return new LongHair( hairHue );
+        }
+        }
+        }
+        public static Hair CreateByID( int id, int hue )
+        {
+        switch ( id )
+        {
+        case 0x203B: return new ShortHair( hue );
+        case 0x203C: return new LongHair( hue );
+        case 0x203D: return new PonyTail( hue );
+        case 0x2044: return new Mohawk( hue );
+        case 0x2045: return new PageboyHair( hue );
+        case 0x2046: return new BunsHair( hue );
+        case 0x2047: return new Afro( hue );
+        case 0x2048: return new ReceedingHair( hue );
+        case 0x2049: return new TwoPigTails( hue );
+        case 0x204A: return new KrisnaHair( hue );
+        default: return new GenericHair( id, hue );
+        }
+        }
+        * */
+        protected Hair(int itemID)
+            : this(itemID, 0)
+        {
+        }
+
+        protected Hair(int itemID, int hue)
+            : base(itemID)
+        {
+            this.LootType = LootType.Blessed;
+            this.Layer = Layer.Hair;
+            this.Hue = hue;
+        }
+
+        public override bool DisplayLootType
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override bool VerifyMove(Mobile from)
+        {
+            return (from.AccessLevel >= AccessLevel.GameMaster);
+        }
+
+        public override DeathMoveResult OnParentDeath(Mobile parent)
+        {
+            //			Dupe( Amount );
+            parent.HairItemID = this.ItemID;
+            parent.HairHue = this.Hue;
+
+            return DeathMoveResult.MoveToCorpse;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            this.LootType = LootType.Blessed;
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GenericHair : Hair
+    {
+        public GenericHair(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private GenericHair(int itemID)
+            : this(itemID, 0)
+        {
+        }
+
+        private GenericHair(int itemID, int hue)
+            : base(itemID, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class Mohawk : Hair
+    {
+        public Mohawk(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private Mohawk()
+            : this(0)
+        {
+        }
+
+        private Mohawk(int hue)
+            : base(0x2044, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class PageboyHair : Hair
+    {
+        public PageboyHair(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private PageboyHair()
+            : this(0)
+        {
+        }
+
+        private PageboyHair(int hue)
+            : base(0x2045, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class BunsHair : Hair
+    {
+        public BunsHair(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private BunsHair()
+            : this(0)
+        {
+        }
+
+        private BunsHair(int hue)
+            : base(0x2046, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class LongHair : Hair
+    {
+        public LongHair(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private LongHair()
+            : this(0)
+        {
+        }
+
+        private LongHair(int hue)
+            : base(0x203C, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class ShortHair : Hair
+    {
+        public ShortHair(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private ShortHair()
+            : this(0)
+        {
+        }
+
+        private ShortHair(int hue)
+            : base(0x203B, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class PonyTail : Hair
+    {
+        public PonyTail(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private PonyTail()
+            : this(0)
+        {
+        }
+
+        private PonyTail(int hue)
+            : base(0x203D, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class Afro : Hair
+    {
+        public Afro(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private Afro()
+            : this(0)
+        {
+        }
+
+        private Afro(int hue)
+            : base(0x2047, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class ReceedingHair : Hair
+    {
+        public ReceedingHair(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private ReceedingHair()
+            : this(0)
+        {
+        }
+
+        private ReceedingHair(int hue)
+            : base(0x2048, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class TwoPigTails : Hair
+    {
+        public TwoPigTails(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private TwoPigTails()
+            : this(0)
+        {
+        }
+
+        private TwoPigTails(int hue)
+            : base(0x2049, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class KrisnaHair : Hair
+    {
+        public KrisnaHair(Serial serial)
+            : base(serial)
+        {
+        }
+
+        private KrisnaHair()
+            : this(0)
+        {
+        }
+
+        private KrisnaHair(int hue)
+            : base(0x204A, hue)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/IDurability.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace Server.Items
+{
+    interface IDurability
+    {
+        bool CanFortify { get; }
+        int InitMinHits { get; }
+        int InitMaxHits { get; }
+        int HitPoints { get; set; }
+        int MaxHitPoints { get; set; }
+        void ScaleDurability();
+
+        void UnscaleDurability();
+    }
+
+    interface IWearableDurability : IDurability
+    {
+        int OnHit(BaseWeapon weapon, int damageTaken);
+    }
+}

Scripts/Items/Internal/InvisibleTile.cs

@@ -0,0 +1,89 @@
+using System;
+using Server;
+using Server.Network;
+
+namespace Server.Items
+{
+    public class InvisibleTile : Item
+    {
+        public override string DefaultName
+        {
+            get { return "Invisible Tile"; }
+        }
+
+        [Constructable]
+        public InvisibleTile()
+            : base(0x2198)
+        {
+            Movable = false;
+        }
+
+        public InvisibleTile(Serial serial)
+            : base(serial)
+        {
+        }
+
+        protected override Packet GetWorldPacketFor(NetState state)
+        {
+            Mobile mob = state.Mobile;
+
+            if (mob != null && mob.AccessLevel >= AccessLevel.GameMaster)
+            {
+                return new LOSBlocker.GMItemPacket(this);
+            }
+
+            return base.GetWorldPacketFor(state);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class RevealTile : Item
+    {
+        [Constructable]
+        public RevealTile()
+            : base(0x2e46)
+        {
+            Movable = false;
+        }
+
+        public override int GetUpdateRange(Mobile m)
+        {
+            if (m.Player)
+                return 1;
+
+            return base.GetUpdateRange(m);
+        }
+
+        public RevealTile(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/ItemInterfaces.cs

@@ -0,0 +1,82 @@
+using System;
+using Server.Mobiles;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    public interface IUsesRemaining
+    {
+        int UsesRemaining { get; set; }
+        bool ShowUsesRemaining { get; set; }
+    }
+
+    public interface IAccountRestricted
+    {
+        string Account { get; set; }
+    }
+
+    public interface IVvVItem
+    {
+        bool IsVvVItem { get; set; }
+    }
+
+    public interface IOwnerRestricted
+    {
+        Mobile Owner { get; set; }
+        string OwnerName { get; set; }
+    }
+
+    public interface IFlipable
+    {
+        void OnFlip(Mobile m);
+    }
+
+    public interface IQuality : ICraftable
+    {
+        ItemQuality Quality { get; set; }
+        bool PlayerConstructed { get; }
+    }
+
+    public interface IResource
+    {
+        CraftResource Resource { get; set; }
+    }
+
+    public interface IConditionalVisibility
+    {
+        bool CanBeSeenBy(PlayerMobile m);
+    }
+
+    public interface IImbuableEquipement
+    {
+        int TimesImbued { get; set; }
+        bool IsImbued { get; set; }
+
+        int[] BaseResists { get; }
+        void OnAfterImbued(Mobile m, int mod, int value);
+    }
+
+    public interface ICombatEquipment : IImbuableEquipement
+    {
+        ItemPower ItemPower { get; set; }
+        ReforgedPrefix ReforgedPrefix { get; set; }
+        ReforgedSuffix ReforgedSuffix { get; set; }
+        bool PlayerConstructed { get; set; }
+    }
+
+    public enum ItemQuality
+    {
+        Low,
+        Normal,
+        Exceptional,
+    }
+
+    public enum DirectionType
+    {
+        None = 0,
+        South = 1,
+        East = 2,
+        North = 3,
+        West = 4
+    }
+}

Scripts/Items/Internal/ItemSockets/Caddellite.cs

@@ -0,0 +1,197 @@
+using System;
+
+using Server;
+using Server.Mobiles;
+using Server.Engines.Craft;
+using Server.Spells;
+using Server.Engines.Points;
+using Server.Engines.Khaldun;
+using Server.Engines.Harvest;
+
+namespace Server.Items
+{
+    public class Caddellite : ItemSocket
+    {
+        public Caddellite()
+        {
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            if (Owner != null && !(Owner is ICombatEquipment) && !(Owner is Spellbook))
+            {
+                list.Add(1158662); // Caddellite Infused
+            }
+        }
+
+        public static void Initialize()
+        {
+            EventSink.Login += OnLogin;
+        }
+
+        public static bool CheckDamage(Mobile from, Server.DamageType type)
+        {
+            if (from is BaseCreature)
+            {
+                if (KhaldunTastyTreat.UnderInfluence((BaseCreature)from))
+                {
+                    return true;
+                }
+
+                return false;
+            }
+            else if (from.Player)
+            {
+                Item damager = from.FindItemOnLayer(Layer.OneHanded);
+
+                if (damager == null)
+                {
+                    damager = from.FindItemOnLayer(Layer.TwoHanded);
+                }
+
+                if (damager != null && damager.HasSocket<Caddellite>())
+                {
+                    switch (type)
+                    {
+                        case Server.DamageType.Melee:
+                        case Server.DamageType.Ranged:
+                            return damager is BaseWeapon;
+                        default:
+                            return damager is Spellbook;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        public static bool IsCaddellite(Mobile from, Item item)
+        {
+            return PointsSystem.Khaldun.InSeason && item is ICaddelliteTool && SpellHelper.IsAnyT2A(from.Map, from.Location);
+        }
+
+        public static void OnHarvest(Mobile from, Item tool, HarvestSystem system, Item resource)
+        {
+            if(IsCaddellite(from, tool))
+            {
+                if (resource != null)
+                {
+                    resource.AttachSocket(new Caddellite());
+                }
+
+                if (0.005 > Utility.RandomDouble())
+                {
+                    if (from != null)
+                    {
+                        if (system == Fishing.System)
+                        {
+                            from.SendLocalizedMessage(1158664); // You discover a meteorite entangled in your line!
+                        }
+                        else if (system == Mining.System)
+                        {
+                            from.SendLocalizedMessage(1158663); // You discover a meteorite in the dirt!
+                        }
+                        else if (system == Lumberjacking.System)
+                        {
+                            from.SendLocalizedMessage(1158665); // You discover a meteorite in the tree!
+                        }
+
+                        from.AddToBackpack(new Meteorite());
+                    }
+                }
+            }
+        }
+
+        private static Rectangle2D _CraftRec = new Rectangle2D(6017, 3743, 8, 8);
+        private static Rectangle2D _CookingRec = new Rectangle2D(6002, 3779, 7, 2);
+        private static Rectangle2D _ScribeRec = new Rectangle2D(5999, 3771, 5, 2);
+
+        public static void CheckWaterSource(Mobile from, BaseBeverage beverage, Item item)
+        {
+            if (from.Region.IsPartOf<KhaldunCampRegion>())
+            {
+                beverage.Content = BeverageType.Water;
+                beverage.Poison = null;
+                beverage.Poisoner = null;
+
+                beverage.Quantity = beverage.MaxQuantity;
+
+                from.SendLocalizedMessage(1010089); // You fill the container with water.
+
+                beverage.AttachSocket(new Caddellite());
+            }
+        }
+
+        public static void TryInfuse(Mobile from, Item item, CraftSystem system)
+        {
+            Rectangle2D rec;
+
+            if (system == DefCooking.CraftSystem || system == DefAlchemy.CraftSystem)
+            {
+                rec = _CookingRec;
+            }
+            else if (system == DefInscription.CraftSystem)
+            {
+                rec = _ScribeRec;
+            }
+            else
+            {
+                rec = _CraftRec;
+            }
+
+            if (rec.Contains(from))
+            {
+                item.AttachSocket(new Caddellite());
+            }
+        }
+
+        public static void UpdateBuff(Mobile m)
+        {
+            BaseCreature pet = KhaldunTastyTreat.GetPetUnderEffects(m);
+            Caddellite equipped = null;
+            var item = m.FindItemOnLayer(Layer.TwoHanded);
+            
+            if (item == null)
+            {
+                item = m.FindItemOnLayer(Layer.OneHanded);
+            }
+
+            if (item != null)
+            {
+                equipped = item.GetSocket<Caddellite>();
+            }
+
+            if (equipped == null && pet == null)
+            {
+                BuffInfo.RemoveBuff(m, BuffIcon.CaddelliteInfused);
+            }
+            else
+            {
+                BuffInfo.AddBuff(m, new BuffInfo(BuffIcon.CaddelliteInfused, 1158662, 1158677,
+                    String.Format("{0}\t{1}\t{2}\t{3}", equipped != null && equipped.Owner is BaseWeapon ? "100" : "0", equipped != null && equipped.Owner is Spellbook ? "100" : "0", pet != null ? pet.Name : "", pet != null ? "100" : "0")));
+            }
+        }
+
+        public static void OnLogin(LoginEventArgs e)
+        {
+            var pm = e.Mobile as PlayerMobile;
+
+            if (pm != null)
+            {
+                UpdateBuff(pm);
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(Item owner, GenericReader reader)
+        {
+            base.Deserialize(owner, reader);
+            reader.ReadInt(); // version
+        }
+    }
+}

Scripts/Items/Internal/ItemSockets/EnchantedHotItem.cs

@@ -0,0 +1,173 @@
+using System;
+
+namespace Server.Items
+{
+    public class EnchantedHotItemSocket : ItemSocket
+    {
+        public Container Container { get; set; }
+
+        public override TimeSpan TickDuration { get { return TimeSpan.FromSeconds(3); } }
+
+        public EnchantedHotItemSocket()
+        {
+        }
+
+        public EnchantedHotItemSocket(Container c)
+        {
+            Container = c;
+
+            BeginTimer();
+        }
+
+        protected override void OnTick()
+        {
+            if (Owner == null || Owner.Deleted)
+            {
+                EndTimer();
+            }
+            else if (Owner.RootParent is Mobile)
+            {
+                if (((Mobile)Owner.RootParent).Region.IsPartOf("Wrong"))
+                {
+                    AOS.Damage((Mobile)Owner.RootParent, Utility.RandomMinMax(10, 13), 0, 100, 0, 0, 0);
+
+                    if (0.2 > Utility.RandomDouble())
+                    {
+                        ((Mobile)Owner.RootParent).SendLocalizedMessage(1152086); // Ouch! These stolen items are hot!
+                    }
+                }
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            list.Add(1152081); // Enchanted Hot Item
+            list.Add(1152082); // (Escape from dungeon to remove spell)
+        }
+
+        public override void OnRemoved()
+        {
+            if (Owner is BaseWeapon)
+            {
+                Owner.Hue = ((BaseWeapon)Owner).GetElementalDamageHue();
+            }
+            else
+            {
+                Owner.Hue = 0;
+            }
+        }
+
+        public override void OnAfterDuped(ItemSocket oldSocket)
+        {
+            if (oldSocket is EnchantedHotItemSocket)
+            {
+                Container = ((EnchantedHotItemSocket)oldSocket).Container;
+            }
+        }
+
+        public static void OnEnterRegion(OnEnterRegionEventArgs e)
+        {
+            Mobile m = e.From;
+
+            if (!m.Player || e.OldRegion == null || e.NewRegion == null || m.Backpack == null)
+                return;
+
+            if (e.OldRegion.IsPartOf("Wrong") && !e.NewRegion.IsPartOf("Wrong"))
+            {
+                bool found = false;
+
+                m.Backpack.Items.IterateReverse(i =>
+                {
+                    var socket = i.GetSocket<EnchantedHotItemSocket>();
+
+                    if (socket != null)
+                    {
+                        found = true;
+                        socket.Remove();
+                    }
+                });
+
+                if (found)
+                {
+                    m.SendLocalizedMessage(1152085); // The curse is removed from the item you stole!
+                }
+            }
+        }
+
+        public static bool CheckDrop(Mobile from, Container droppedTo, Item dropped)
+        {
+            var socket = dropped.GetSocket<EnchantedHotItemSocket>();
+
+            if (socket != null)
+            {
+                Container c = socket.Container;
+
+                if (droppedTo != c && droppedTo != from.Backpack)
+                {
+                    from.SendLocalizedMessage(1152083); // The stolen item magically returns to the trunk where you found it.
+
+                    if (c != null)
+                    {
+                        c.DropItem(dropped);
+                    }
+                    else
+                    {
+                        dropped.Delete();
+                    }
+
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static bool CheckDrop(Mobile from, Item dropped)
+        {
+            var socket = dropped.GetSocket<EnchantedHotItemSocket>();
+
+            if (socket != null)
+            {
+                Container c = socket.Container;
+
+                from.SendLocalizedMessage(1152083); // The stolen item magically returns to the trunk where you found it.
+
+                if (c != null)
+                {
+                    c.DropItem(dropped);
+                }
+                else
+                {
+                    dropped.Delete();
+                }
+
+                return false;
+            }
+
+            return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write(Container);
+        }
+
+        public override void Deserialize(Item owner, GenericReader reader)
+        {
+            base.Deserialize(owner, reader);
+            reader.ReadInt(); // version
+
+            Container = reader.ReadItem() as Container;
+
+            BeginTimer();
+        }
+
+        public static void Initialize()
+        {
+            EventSink.OnEnterRegion += OnEnterRegion;
+        }
+    }
+}

Scripts/Items/Internal/ItemSockets/HonestyItem.cs

@@ -0,0 +1,145 @@
+using System;
+using Server.Services.Virtues;
+
+namespace Server.Items
+{
+    public class HonestyItemSocket : ItemSocket
+    {
+        public const int ExpireTime = 3;
+
+        public string HonestyRegion { get; set; }
+        public Mobile HonestyOwner { get; set; }
+        public Timer HonestyTimer { get; set; }
+        public DateTime HonestyPickup { get; set; }
+        public bool HonestyTimerTicking { get; set; }
+
+        public override TimeSpan TickDuration { get { return TimeSpan.FromSeconds(5); } }
+
+        public HonestyItemSocket()
+        {
+        }
+
+        public void StartHonestyTimer()
+        {
+            HonestyTimerTicking = true;
+
+            BeginTimer();
+        }
+
+        protected override void OnTick()
+        {
+            if ((HonestyPickup + TimeSpan.FromHours(ExpireTime)) < DateTime.UtcNow)
+            {
+                Remove();
+            }
+            else
+            {
+                Owner.InvalidateProperties();
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            if (HonestyPickup != DateTime.MinValue)
+            {
+                int minutes = (int)(HonestyPickup + TimeSpan.FromHours(3) - DateTime.UtcNow).TotalMinutes;
+                list.Add(1151914, minutes.ToString()); // Minutes remaining for credit: ~1_val~
+            }
+
+            list.Add(1151520); // lost item (Return to gain Honesty)
+        }
+
+        public override void OnRemoved()
+        {
+            if (Owner != null && !Owner.Deleted)
+            {
+                Owner.HonestyItem = false;
+
+                if (Owner.RootParent is Mobile)
+                {
+                    ((Mobile)Owner.RootParent).SendLocalizedMessage(1151519); // You claim the item as your own.  Finders keepers, losers weepers!
+                }
+            }
+        }
+
+        public override void OnAfterDuped(ItemSocket oldSocket)
+        {
+            if (oldSocket is HonestyItemSocket)
+            {
+                var honesty = oldSocket as HonestyItemSocket;
+
+                HonestyRegion = honesty.HonestyRegion;
+                HonestyOwner = honesty.HonestyOwner;
+                HonestyPickup = honesty.HonestyPickup;
+                HonestyTimerTicking = honesty.HonestyTimerTicking;
+
+                if (HonestyTimerTicking)
+                {
+                    BeginTimer();
+                }
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write(HonestyRegion);
+            writer.Write(HonestyOwner);
+            writer.Write(HonestyPickup);
+            writer.Write(HonestyTimerTicking);
+        }
+
+        public override void Deserialize(Item owner, GenericReader reader)
+        {
+            base.Deserialize(owner, reader);
+            reader.ReadInt(); // version
+
+            HonestyRegion = reader.ReadString();
+            HonestyOwner = reader.ReadMobile();
+            HonestyPickup = reader.ReadDateTime();
+            HonestyTimerTicking = reader.ReadBool();
+
+            Owner.HonestyItem = true;
+
+            if (HonestyTimerTicking)
+            {
+                BeginTimer();
+            }
+        }
+
+        public static void Initialize()
+        {
+            if (HonestyVirtue.Enabled)
+            {
+                EventSink.ContainerDroppedTo += OnDropped;
+            }
+        }
+
+        public static void OnDropped(ContainerDroppedToEventArgs e)
+        {
+            var dropped = e.Dropped;
+            var from = e.Mobile;
+
+            if (dropped != null)
+            {
+                var honestySocket = dropped.GetSocket<HonestyItemSocket>();
+
+                if (honestySocket != null && honestySocket.HonestyPickup == DateTime.MinValue)
+                {
+                    honestySocket.HonestyPickup = DateTime.UtcNow;
+                    honestySocket.StartHonestyTimer();
+
+                    if (honestySocket.HonestyOwner == null)
+                        Server.Services.Virtues.HonestyVirtue.AssignOwner(honestySocket);
+
+                    if (from != null)
+                    {
+                        from.SendLocalizedMessage(1151536); // You have three hours to turn this item in for Honesty credit, otherwise it will cease to be a quest item.
+                    }
+                }
+            }
+        }
+    }
+}

Scripts/Items/Internal/ItemSockets/SearingWeapon.cs

@@ -0,0 +1,110 @@
+using System;
+
+using Server.ContextMenus;
+
+namespace Server.Items
+{
+    public class SearingWeapon : ItemSocket
+    {
+        public bool Extinguished { get; set; } = true;
+
+        public SearingWeapon()
+        {
+        }
+
+        public SearingWeapon(BaseWeapon wep)
+        {
+            wep.NegativeAttributes.Brittle = 1;
+            wep.MaxHitPoints = 200;
+            wep.HitPoints = 200;
+            wep.Hue = 2500;
+        }
+
+        public override void OnRemoved()
+        {
+            if (Owner is BaseWeapon)
+            {
+                ((BaseWeapon)Owner).NegativeAttributes.Brittle = 0;
+                Owner.Hue = ((BaseWeapon)Owner).GetElementalDamageHue();
+            }
+        }
+
+        public static void OnWeaponRemoved(BaseWeapon wep)
+        {
+            var socket = wep.GetSocket<SearingWeapon>();
+
+            if (socket != null && !socket.Extinguished)
+            {
+                socket.Extinguished = true;
+                wep.Hue = 2500;
+            }
+        }
+
+        public void ToggleExtinguish(Mobile from)
+        {
+            if (Extinguished)
+            {
+                Extinguished = false;
+                Owner.Hue = 1174;
+
+                from.SendLocalizedMessage(1151175); // You ignite your weapon.
+            }
+            else
+            {
+                Extinguished = true;
+                Owner.Hue = 2500;
+
+                from.SendLocalizedMessage(1151176); // You extinguish your weapon.
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write(Extinguished);
+        }
+
+        public static bool CanSear(BaseWeapon weapon)
+        {
+            var socket = weapon.GetSocket<SearingWeapon>();
+
+            return socket != null && !socket.Extinguished;
+        }
+
+        public override void Deserialize(Item owner, GenericReader reader)
+        {
+            base.Deserialize(owner, reader);
+            reader.ReadInt(); // version
+
+            Extinguished = reader.ReadBool();
+        }
+
+        public class ToggleExtinguishEntry : ContextMenuEntry
+        {
+            public BaseWeapon Weapon { get; set; }
+            public Mobile From { get; set; }
+
+            public ToggleExtinguishEntry(Mobile from, BaseWeapon weapon)
+                : base(weapon.GetSocket<SearingWeapon>().Extinguished ? 1151173 : 1151174, -1)
+            {
+                From = from;
+                Weapon = weapon;
+            }
+
+            public override void OnClick()
+            {
+                if (Weapon.Parent == From)
+                {
+                    var socket = Weapon.GetSocket<SearingWeapon>();
+
+                    if (socket != null)
+                    {
+                        socket.ToggleExtinguish(From);
+                    }
+                }
+            }
+        }
+    }
+}

Scripts/Items/Internal/ItemSockets/SlayerSocket.cs

@@ -0,0 +1,73 @@
+using System;
+
+namespace Server.Items
+{
+    public class SlayerSocket : ItemSocket
+    {
+        public SlayerName Slayer { get; set; }
+
+        public SlayerSocket()
+        {
+        }
+
+        public SlayerSocket(SlayerName slayer, TimeSpan duration)
+            : base(duration)
+        {
+            Slayer = slayer;
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            list.Add(1155617); // Silvered
+        }
+
+        public override void OnRemoved()
+        {
+            if (Owner != null && !Owner.Deleted && Owner.RootParent is Mobile)
+            {
+                ((Mobile)Owner.RootParent).SendLocalizedMessage(1155618, String.IsNullOrEmpty(Owner.Name) ? String.Format("#{0}", Owner.LabelNumber) : Owner.Name); // Your ~1_name~'s Tincture of Silver has worn off.
+            }
+        }
+
+        public static SlayerName GetSlayer(Item item)
+        {
+            if (item == null)
+            {
+                return SlayerName.None;
+            }
+
+            var socket = item.GetSocket<SlayerSocket>();
+
+            if (socket != null)
+            {
+                return socket.Slayer;
+            }
+
+            return SlayerName.None;
+        }
+
+        public override void OnAfterDuped(ItemSocket oldSocket)
+        {
+            if (oldSocket is SlayerSocket)
+            {
+                Slayer = ((SlayerSocket)oldSocket).Slayer;
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write((int)Slayer);
+        }
+
+        public override void Deserialize(Item owner, GenericReader reader)
+        {
+            base.Deserialize(owner, reader);
+            reader.ReadInt(); // version
+
+            Slayer = (SlayerName)reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/LOSBlocker.cs

@@ -0,0 +1,125 @@
+using System;
+using Server.Network;
+
+namespace Server.Items
+{
+    public class LOSBlocker : Item
+    {
+        [Constructable]
+        public LOSBlocker()
+            : base(0x21A2)
+        {
+            this.Movable = false;
+        }
+
+        public LOSBlocker(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override string DefaultName
+        {
+            get
+            {
+                return "no line of sight";
+            }
+        }
+        public static void Initialize()
+        {
+            TileData.ItemTable[0x21A2].Flags = TileFlag.Wall | TileFlag.NoShoot;
+            TileData.ItemTable[0x21A2].Height = 20;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            if (version < 1 && this.ItemID == 0x2199)
+                this.ItemID = 0x21A2;
+        }
+
+        protected override Packet GetWorldPacketFor(NetState state)
+        {
+            Mobile mob = state.Mobile;
+
+            if (mob != null && mob.AccessLevel >= AccessLevel.GameMaster)
+            {
+                return new GMItemPacket(this);
+            }
+
+            return base.GetWorldPacketFor(state);
+        }
+
+        public sealed class GMItemPacket : Packet
+        {
+            public GMItemPacket(Item item)
+                : base(0x1A)
+            {
+                this.EnsureCapacity(20);
+
+                // 14 base length
+                // +2 - Amount
+                // +2 - Hue
+                // +1 - Flags
+
+                uint serial = (uint)item.Serial.Value;
+                int itemID = 0x36FF;
+                int amount = item.Amount;
+                Point3D loc = item.Location;
+                int x = loc.X;
+                int y = loc.Y;
+                int hue = item.Hue;
+                int flags = item.GetPacketFlags();
+                int direction = (int)item.Direction;
+
+                if (amount != 0)
+                    serial |= 0x80000000;
+                else
+                    serial &= 0x7FFFFFFF;
+
+                this.m_Stream.Write((uint)serial);
+				this.m_Stream.Write((short)(itemID & TileData.MaxItemValue));
+
+                if (amount != 0)
+                    this.m_Stream.Write((short)amount);
+
+                x &= 0x7FFF;
+
+                if (direction != 0)
+                    x |= 0x8000;
+
+                this.m_Stream.Write((short)x);
+
+                y &= 0x3FFF;
+
+                if (hue != 0)
+                    y |= 0x8000;
+
+                if (flags != 0)
+                    y |= 0x4000;
+
+                this.m_Stream.Write((short)y);
+
+                if (direction != 0)
+                    this.m_Stream.Write((byte)direction);
+
+                this.m_Stream.Write((sbyte)loc.Z);
+
+                if (hue != 0)
+                    this.m_Stream.Write((ushort)hue);
+
+                if (flags != 0)
+                    this.m_Stream.Write((byte)flags);
+            }
+        }
+    }
+}

Scripts/Items/Internal/LabyrinthTeleporters.cs

@@ -0,0 +1,91 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class LabyrinthIslandTele : Item
+    { 
+        [Constructable]
+        public LabyrinthIslandTele()
+            : base(0x2FD4)
+        { 
+            this.Movable = false;
+        }
+
+        public LabyrinthIslandTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        { 
+            if (MondainsLegacy.Labyrinth && from.InRange(this.Location, 2))
+                from.MoveToWorld(new Point3D(1731, 978, -80), this.Map);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class LabyrinthTele : Item
+    { 
+        [Constructable]
+        public LabyrinthTele()
+            : base(0x248B)
+        { 
+            this.Movable = false;
+        }
+
+        public LabyrinthTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        { 
+            if (from.NetState == null || !from.NetState.SupportsExpansion(Expansion.ML))
+            {
+                from.SendLocalizedMessage(1072608); // You must upgrade to the Mondain's Legacy expansion in order to enter here.				
+                return;
+            }
+            else if (!MondainsLegacy.Labyrinth && (int)from.AccessLevel < (int)AccessLevel.GameMaster)
+            {
+                from.SendLocalizedMessage(1042753, "Labyrinth"); // ~1_SOMETHING~ has been temporarily disabled.
+                return;
+            }
+		
+            if (from.InRange(this.Location, 2))
+            {
+                Point3D p = new Point3D(330, 1973, 0);
+				
+                BaseCreature.TeleportPets(from, p, this.Map);
+                from.MoveToWorld(p, this.Map);
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/MacawSpawner.cs

@@ -0,0 +1,236 @@
+using System;
+using Server.Items;
+using Server.Mobiles;
+using Server.Network;
+using System.Collections.Generic;
+
+namespace Server.Items
+{
+    public class MacawSpawner : Item
+    {
+        public override int LabelNumber { get { return 1124032; } } // foil sheet
+
+        public List<BaseCreature> Spawn { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public MacawNest Addon { get; set; }
+
+        public bool Moving { get; private set; }
+
+        [Constructable]
+        public MacawSpawner()
+            : base(0x9C48)
+        {
+            Spawn = new List<BaseCreature>();
+            Movable = false;
+            Hue = 1281;
+
+            Addon = new MacawNest();
+            Addon.Foil = this;
+        }
+
+        public override bool VerifyMove( Mobile from )
+        {
+            if (this.Visible && this.Map != null && this.Map != Map.Internal && Utility.RandomBool())
+            {
+                SpawnBirdies(from);
+            }
+
+            return base.VerifyMove(from);
+        }
+
+        public void SpawnBirdies(Mobile from)
+        {
+            int count = Utility.RandomMinMax(3, 5);
+
+            for (int i = 0; i < count; i++)
+            {
+                Point3D p = Location;
+
+                for (int j = 0; j < 10; j++)
+                {
+                    int x = Utility.RandomMinMax(X - 1, X + 1);
+                    int y = Utility.RandomMinMax(Y - 1, Y + 2);
+                    int z = this.Map.GetAverageZ(x, y);
+
+                    if (this.Map.CanSpawnMobile(x, y, z))
+                    {
+                        p = new Point3D(x, y, z);
+                        break;
+                    }
+                }
+
+                BaseCreature macaw = new Macaw(this);
+                macaw.MoveToWorld(p, this.Map);
+                Spawn.Add(macaw);
+
+                Visible = false;
+                Timer.DelayCall(TimeSpan.FromSeconds(Utility.RandomMinMax(60, 90)), () => Visible = true);
+            }
+
+            Spawn.ForEach(s => s.Combatant = from);
+        }
+
+        public override void OnLocationChange(Point3D oldLocation)
+        {
+            if (this.Location != oldLocation && Addon != null && !Moving)
+                MoveToNest();
+
+            base.OnLocationChange(oldLocation);
+        }
+
+        public override void OnMapChange()
+        {
+            if (Addon != null)
+                Addon.Map = this.Map;
+
+            base.OnMapChange();
+        }
+
+        private void MoveToNest()
+        {
+            Addon.MoveToWorld(this.Location, this.Map);
+            Moving = true;
+            MoveToWorld(new Point3D(Addon.X + 1, Addon.Y, Addon.Z + 9), Addon.Map);
+            Moving = false;
+        }
+
+        public override void Delete()
+        {
+            base.Delete();
+
+            if (Addon != null)
+            {
+                Addon.Foil = null;
+                Addon.Delete();
+            }
+        }
+
+        public MacawSpawner(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0);
+
+            writer.Write(Addon);
+            writer.Write(Spawn.Count);
+
+            Spawn.ForEach(sp => writer.Write(sp));
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            Addon = reader.ReadItem() as MacawNest;
+
+            Spawn = new List<BaseCreature>();
+            int count = reader.ReadInt();
+
+            for (int i = 0; i < count; i++)
+            {
+                BaseCreature bc = reader.ReadMobile() as BaseCreature;
+
+                if (bc != null)
+                {
+                    Spawn.Add(bc);
+
+                    if (bc is Macaw)
+                        ((Macaw)bc).MacawSpawner = this;
+                }
+            }
+
+            if (Addon != null)
+                Addon.Foil = this;
+        }
+
+        public static void Generate()
+        {
+            foreach (Point3D pnt in _SpawnLocs)
+            {
+                MacawNest nest = new MacawNest();
+                nest.MoveToWorld(pnt, Map.TerMur);
+            }
+        }
+
+        private static Point3D[] _SpawnLocs =
+        {
+            new Point3D(491, 1863, 95),
+            new Point3D(496, 1865, 85),
+            new Point3D(496, 1852, 85),
+            new Point3D(490, 1867, 75),
+            new Point3D(494, 1859, 95),
+            new Point3D(498, 1845, 75),
+            new Point3D(502, 1859, 55),
+            new Point3D(484, 1871, 55),
+            new Point3D(476, 1867, 75),
+            new Point3D(500, 1864, 65),
+            new Point3D(484, 1865, 85),
+            new Point3D(500, 1852, 65),
+            new Point3D(493, 1847, 94),
+            new Point3D(479, 1869, 65),
+            new Point3D(502, 1871, 55),
+            new Point3D(502, 1848, 55),
+            new Point3D(498, 1860, 75),
+            new Point3D(498, 1849, 75),
+            new Point3D(500, 1845, 65),
+            new Point3D(472, 1871, 55),
+            new Point3D(495, 1869, 65),
+            new Point3D(490, 1871, 55),
+            new Point3D(478, 1865, 85),
+        };
+    }
+
+    public class MacawNest : BaseAddon
+    {
+        [CommandProperty(AccessLevel.GameMaster)]
+        public MacawSpawner Foil { get; set; }
+
+        [Constructable]
+        public MacawNest()
+        {
+            AddComponent(new AddonComponent(3235), 0, 0, 0);
+            AddComponent(new AddonComponent(3232), 0, 0, 0);
+            AddComponent(new AddonComponent(3236), 1, 0, 0);
+            AddComponent(new AddonComponent(3232), 1, -1, 0);
+            AddComponent(new AddonComponent(3231), 0, -1, 0);
+        }
+
+        public override void Delete()
+        {
+            base.Delete();
+
+            if (Foil != null)
+            {
+                Foil.Addon = null;
+                Foil.Delete();
+            }
+        }
+
+        public MacawNest(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/Moongate.cs

@@ -0,0 +1,458 @@
+#region References
+using System;
+
+using Server.Factions;
+using Server.Gumps;
+using Server.Misc;
+using Server.Mobiles;
+using Server.Multis;
+using Server.Network;
+using Server.Regions;
+using Server.Spells;
+#endregion
+
+namespace Server.Items
+{
+	[DispellableField]
+	public class Moongate : Item
+	{
+		[CommandProperty(AccessLevel.GameMaster)]
+		public Point3D Target { get; set; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public Map TargetMap { get; set; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public bool Dispellable { get; set; }
+
+		public virtual bool ShowFeluccaWarning { get { return false; } }
+
+		public virtual bool TeleportPets { get { return true; } }
+
+		[Constructable]
+		public Moongate()
+			: this(Point3D.Zero, null)
+		{
+			Dispellable = true;
+		}
+
+		[Constructable]
+		public Moongate(bool bDispellable)
+			: this(Point3D.Zero, null)
+		{
+			Dispellable = bDispellable;
+		}
+
+		[Constructable]
+		public Moongate(Point3D target, Map targetMap)
+			: base(0xF6C)
+		{
+			Movable = false;
+			Light = LightType.Circle300;
+
+			Target = target;
+			TargetMap = targetMap;
+		}
+
+		public Moongate(Serial serial)
+			: base(serial)
+		{ }
+
+		public override void OnDoubleClick(Mobile from)
+		{
+			if (!from.Player)
+				return;
+
+			if (from.InRange(GetWorldLocation(), 1))
+				CheckGate(from, 1);
+			else
+				from.SendLocalizedMessage(500446); // That is too far away.
+		}
+
+		public override bool OnMoveOver(Mobile m)
+		{
+			if (m.Player)
+				CheckGate(m, 0);
+
+			return true;
+		}
+
+		public virtual void CheckGate(Mobile m, int range)
+		{
+			#region Mondain's Legacy
+			if (m.Hidden && m.IsPlayer() && Core.ML)
+				m.RevealingAction();
+			#endregion
+
+			new DelayTimer(m, this, range).Start();
+		}
+
+		public virtual void OnGateUsed(Mobile m)
+		{
+			if (TargetMap == null || TargetMap == Map.Internal)
+				return;
+
+			if (TeleportPets)
+				BaseCreature.TeleportPets(m, Target, TargetMap);
+
+			m.MoveToWorld(Target, TargetMap);
+
+			if (m.IsPlayer() || !m.Hidden)
+				m.PlaySound(0x1FE);
+		}
+
+		public virtual void UseGate(Mobile m)
+		{
+			var flags = m.NetState == null ? ClientFlags.None : m.NetState.Flags;
+
+			if (Sigil.ExistsOn(m))
+			{
+				m.SendLocalizedMessage(1061632); // You can't do that while carrying the sigil.
+			}
+			else if (TargetMap == Map.Felucca && m is PlayerMobile && ((PlayerMobile)m).Young)
+			{
+				m.SendLocalizedMessage(1049543); // You decide against traveling to Felucca while you are still young.
+			}
+            else if ((SpellHelper.RestrictRedTravel && m.Murderer && TargetMap != Map.Felucca && !Siege.SiegeShard) ||
+					 (TargetMap == Map.Tokuno && (flags & ClientFlags.Tokuno) == 0) ||
+					 (TargetMap == Map.Malas && (flags & ClientFlags.Malas) == 0) ||
+					 (TargetMap == Map.Ilshenar && (flags & ClientFlags.Ilshenar) == 0))
+			{
+				m.SendLocalizedMessage(1019004); // You are not allowed to travel there.
+			}
+			else if (m.Spell != null || BaseBoat.IsDriving(m))
+			{
+				m.SendLocalizedMessage(1049616); // You are too busy to do that at the moment.
+			}
+			else if (m.Holding != null)
+			{
+				m.SendLocalizedMessage(1071955); // You cannot teleport while dragging an object.
+			}
+			else if (TargetMap != null && TargetMap != Map.Internal)
+			{
+				OnGateUsed(m);
+			}
+			else
+			{
+				m.SendLocalizedMessage(1113744); // This moongate is not yet bonded to the magics of Sosaria.
+			}
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.Write(1); // version
+
+			writer.Write(Target);
+			writer.Write(TargetMap);
+
+			// Version 1
+			writer.Write(Dispellable);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.ReadInt();
+
+			Target = reader.ReadPoint3D();
+			TargetMap = reader.ReadMap();
+
+			if (version >= 1)
+				Dispellable = reader.ReadBool();
+		}
+
+		public virtual bool ValidateUse(Mobile from, bool message)
+		{
+			if (from.Deleted || Deleted)
+				return false;
+
+			if (from.Map != Map || !from.InRange(this, 1))
+			{
+				if (message)
+					from.SendLocalizedMessage(500446); // That is too far away.
+
+				return false;
+			}
+
+			return true;
+		}
+
+		public virtual void BeginConfirmation(Mobile from)
+		{
+			if (IsInTown(from.Location, from.Map) && !IsInTown(Target, TargetMap) ||
+				(from.Map != Map.Felucca && TargetMap == Map.Felucca && ShowFeluccaWarning))
+			{
+				if (from.IsPlayer() || !from.Hidden)
+					from.Send(new PlaySound(0x20E, from.Location));
+				from.CloseGump(typeof(MoongateConfirmGump));
+				from.SendGump(new MoongateConfirmGump(from, this));
+			}
+			else
+			{
+				EndConfirmation(from);
+			}
+		}
+
+		public virtual void EndConfirmation(Mobile from)
+		{
+			if (!ValidateUse(from, true))
+				return;
+
+			UseGate(from);
+		}
+
+		public virtual void DelayCallback(Mobile from, int range)
+		{
+			if (!ValidateUse(from, false) || !from.InRange(this, range))
+				return;
+
+			if (TargetMap != null)
+				BeginConfirmation(from);
+			else
+				from.SendMessage("This moongate does not seem to go anywhere.");
+		}
+
+		public static bool IsInTown(Point3D p, Map map)
+		{
+			if (map == null)
+				return false;
+
+			var reg = (GuardedRegion)Region.Find(p, map).GetRegion(typeof(GuardedRegion));
+
+			return (reg != null && !reg.IsDisabled());
+		}
+
+		private class DelayTimer : Timer
+		{
+			private readonly Mobile m_From;
+			private readonly Moongate m_Gate;
+			private readonly int m_Range;
+
+			public DelayTimer(Mobile from, Moongate gate, int range)
+				: base(TimeSpan.FromSeconds(1.0))
+			{
+				m_From = from;
+				m_Gate = gate;
+				m_Range = range;
+			}
+
+			protected override void OnTick()
+			{
+				m_Gate.DelayCallback(m_From, m_Range);
+			}
+		}
+	}
+
+	public class ConfirmationMoongate : Moongate
+	{
+		[CommandProperty(AccessLevel.GameMaster)]
+		public int GumpWidth { get; set; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public int GumpHeight { get; set; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public int TitleColor { get; set; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public int MessageColor { get; set; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public int TitleNumber { get; set; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public string TitleString { get; set; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public int MessageNumber { get; set; }
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public string MessageString { get; set; }
+
+		[Constructable]
+		public ConfirmationMoongate()
+			: this(Point3D.Zero, null)
+		{ }
+
+		[Constructable]
+		public ConfirmationMoongate(Point3D target, Map targetMap)
+			: base(target, targetMap)
+		{ }
+
+		public ConfirmationMoongate(Serial serial)
+			: base(serial)
+		{ }
+
+		public virtual void Warning_Callback(Mobile from, bool okay, object state)
+		{
+			if (okay)
+				EndConfirmation(from);
+		}
+
+		public override void BeginConfirmation(Mobile from)
+		{
+			if (GumpWidth > 0 && GumpHeight > 0 && (TitleNumber > 0 || TitleString != null) &&
+				(MessageNumber > 0 || MessageString != null))
+			{
+				from.CloseGump(typeof(WarningGump));
+
+				from.SendGump(
+					new WarningGump(
+						new TextDefinition(TitleNumber, TitleString),
+						TitleColor,
+						new TextDefinition(MessageNumber, MessageString),
+						MessageColor,
+						GumpWidth,
+						GumpHeight,
+						Warning_Callback,
+						from));
+			}
+			else
+			{
+				base.BeginConfirmation(from);
+			}
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.Write(1); // version
+
+			writer.Write(TitleString);
+
+			writer.WriteEncodedInt(GumpWidth);
+			writer.WriteEncodedInt(GumpHeight);
+
+			writer.WriteEncodedInt(TitleColor);
+			writer.WriteEncodedInt(MessageColor);
+
+			writer.WriteEncodedInt(TitleNumber);
+			writer.WriteEncodedInt(MessageNumber);
+
+			writer.Write(MessageString);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			var version = reader.ReadInt();
+
+			switch (version)
+			{
+				case 1:
+				{
+					TitleString = reader.ReadString();
+					goto case 0;
+				}
+				case 0:
+				{
+					GumpWidth = reader.ReadEncodedInt();
+					GumpHeight = reader.ReadEncodedInt();
+
+					TitleColor = reader.ReadEncodedInt();
+					MessageColor = reader.ReadEncodedInt();
+
+					TitleNumber = reader.ReadEncodedInt();
+					MessageNumber = reader.ReadEncodedInt();
+
+					MessageString = reader.ReadString();
+
+					break;
+				}
+			}
+		}
+	}
+
+	public class MoongateConfirmGump : Gump
+	{
+		private readonly Mobile m_From;
+		private readonly Moongate m_Gate;
+
+		public MoongateConfirmGump(Mobile from, Moongate gate)
+			: base(Core.AOS ? 110 : 20, Core.AOS ? 100 : 30)
+		{
+			m_From = from;
+			m_Gate = gate;
+
+			if (Core.AOS)
+			{
+				Closable = false;
+
+				AddPage(0);
+
+				AddBackground(0, 0, 420, 280, 5054);
+
+				AddImageTiled(10, 10, 400, 20, 2624);
+				AddAlphaRegion(10, 10, 400, 20);
+
+				AddHtmlLocalized(10, 10, 400, 20, 1062051, 30720, false, false); // Gate Warning
+
+				AddImageTiled(10, 40, 400, 200, 2624);
+				AddAlphaRegion(10, 40, 400, 200);
+
+				if (from.Map != Map.Felucca && gate.TargetMap == Map.Felucca && gate.ShowFeluccaWarning)
+					AddHtmlLocalized(
+						10,
+						40,
+						400,
+						200,
+						1062050,
+						32512,
+						false,
+						true); // This Gate goes to Felucca... Continue to enter the gate, Cancel to stay here
+				else
+					AddHtmlLocalized(
+						10,
+						40,
+						400,
+						200,
+						1062049,
+						32512,
+						false,
+						true); // Dost thou wish to step into the moongate? Continue to enter the gate, Cancel to stay here
+
+				AddImageTiled(10, 250, 400, 20, 2624);
+				AddAlphaRegion(10, 250, 400, 20);
+
+				AddButton(10, 250, 4005, 4007, 1, GumpButtonType.Reply, 0);
+				AddHtmlLocalized(40, 250, 170, 20, 1011036, 32767, false, false); // OKAY
+
+				AddButton(210, 250, 4005, 4007, 0, GumpButtonType.Reply, 0);
+				AddHtmlLocalized(240, 250, 170, 20, 1011012, 32767, false, false); // CANCEL
+			}
+			else
+			{
+				AddPage(0);
+
+				AddBackground(0, 0, 420, 400, 5054);
+				AddBackground(10, 10, 400, 380, 3000);
+
+				AddHtml(
+					20,
+					40,
+					380,
+					60,
+					@"Dost thou wish to step into the moongate? Continue to enter the gate, Cancel to stay here",
+					false,
+					false);
+
+				AddHtmlLocalized(55, 110, 290, 20, 1011012, false, false); // CANCEL
+				AddButton(20, 110, 4005, 4007, 0, GumpButtonType.Reply, 0);
+
+				AddHtmlLocalized(55, 140, 290, 40, 1011011, false, false); // CONTINUE
+				AddButton(20, 140, 4005, 4007, 1, GumpButtonType.Reply, 0);
+			}
+		}
+
+		public override void OnResponse(NetState state, RelayInfo info)
+		{
+			if (info.ButtonID == 1)
+				m_Gate.EndConfirmation(m_From);
+		}
+	}
+}

Scripts/Items/Internal/MoonstoneGate.cs

@@ -0,0 +1,85 @@
+using System;
+using Server.Engines.PartySystem;
+using Server.Spells;
+
+namespace Server.Items
+{
+    public class MoonstoneGate : Moongate
+    {
+        private readonly Mobile m_Caster;
+        public MoonstoneGate(Point3D loc, Map map, Map targetMap, Mobile caster, int hue)
+            : base(loc, targetMap)
+        {
+            this.MoveToWorld(loc, map);
+            this.Dispellable = false;
+            this.Hue = hue;
+
+            this.m_Caster = caster;
+
+            new InternalTimer(this).Start();
+
+            Effects.PlaySound(loc, map, 0x20E);
+        }
+
+        public MoonstoneGate(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void CheckGate(Mobile m, int range)
+        {
+            if (SpellHelper.RestrictRedTravel && m.Murderer)
+                return;
+
+            Party casterParty = Party.Get(this.m_Caster);
+            Party userParty = Party.Get(m);
+
+            if (m == this.m_Caster || (casterParty != null && userParty == casterParty))
+                base.CheckGate(m, range);
+        }
+
+        public override void UseGate(Mobile m)
+        {
+            if (m.Murderer)
+                return;
+
+            Party casterParty = Party.Get(this.m_Caster);
+            Party userParty = Party.Get(m);
+
+            if (m == this.m_Caster || (casterParty != null && userParty == casterParty))
+                base.UseGate(m);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            this.Delete();
+        }
+
+        private class InternalTimer : Timer
+        {
+            private readonly Item m_Item;
+            public InternalTimer(Item item)
+                : base(TimeSpan.FromSeconds(30.0))
+            {
+                this.m_Item = item;
+                this.Priority = TimerPriority.OneSecond;
+            }
+
+            protected override void OnTick()
+            {
+                this.m_Item.Delete();
+            }
+        }
+    }
+}

Scripts/Items/Internal/MorphItem.cs

@@ -0,0 +1,184 @@
+using System;
+
+namespace Server.Items
+{
+    public class MorphItem : Item
+    {
+        private int m_InactiveItemID;
+        private int m_ActiveItemID;
+        private int m_RangeCheck;
+        private int m_OutRange;
+        [Constructable]
+        public MorphItem(int inactiveItemID, int activeItemID, int range)
+            : this(inactiveItemID, activeItemID, range, range)
+        {
+        }
+
+        [Constructable]
+        public MorphItem(int inactiveItemID, int activeItemID, int inRange, int outRange)
+            : base(inactiveItemID)
+        {
+            Movable = false;
+
+            InactiveItemID = inactiveItemID;
+            ActiveItemID = activeItemID;
+            RangeCheck = inRange;
+            OutRange = outRange;
+        }
+
+        public MorphItem(Serial serial)
+            : base(serial)
+        {
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int InactiveItemID
+        {
+            get
+            {
+                return m_InactiveItemID;
+            }
+            set
+            {
+                m_InactiveItemID = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int ActiveItemID
+        {
+            get
+            {
+                return m_ActiveItemID;
+            }
+            set
+            {
+                m_ActiveItemID = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int RangeCheck
+        {
+            get
+            {
+                return m_RangeCheck;
+            }
+            set
+            {
+                if (value > 18)
+                    value = 18;
+                m_RangeCheck = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int OutRange
+        {
+            get
+            {
+                return m_OutRange;
+            }
+            set
+            {
+                if (value > 18)
+                    value = 18;
+                m_OutRange = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int CurrentRange
+        {
+            get
+            {
+                return ItemID == InactiveItemID ? RangeCheck : OutRange;
+            }
+        }
+        public override bool HandlesOnMovement
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void OnMovement(Mobile m, Point3D oldLocation)
+        {
+            if (Utility.InRange(m.Location, Location, CurrentRange) || Utility.InRange(oldLocation, Location, CurrentRange))
+                Refresh();
+        }
+
+        public override void OnMapChange()
+        {
+            if (!Deleted)
+                Refresh();
+        }
+
+        public override void OnLocationChange(Point3D oldLoc)
+        {
+            if (!Deleted)
+                Refresh();
+        }
+
+        public void Refresh()
+        {
+            bool found = false;
+            IPooledEnumerable eable = GetMobilesInRange(CurrentRange);
+
+            foreach (Mobile mob in eable)
+            {
+                if (mob.Hidden && mob.IsStaff())
+                    continue;
+
+                found = true;
+                break;
+            }
+            eable.Free();
+
+            if (found)
+                ItemID = ActiveItemID;
+            else
+                ItemID = InactiveItemID;
+
+            Visible = (ItemID != 0x1);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1); // version
+
+            writer.Write((int)m_OutRange);
+
+            writer.Write((int)m_InactiveItemID);
+            writer.Write((int)m_ActiveItemID);
+            writer.Write((int)m_RangeCheck);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 1:
+                    {
+                        m_OutRange = reader.ReadInt();
+                        goto case 0;
+                    }
+                case 0:
+                    {
+                        m_InactiveItemID = reader.ReadInt();
+                        m_ActiveItemID = reader.ReadInt();
+                        m_RangeCheck = reader.ReadInt();
+
+                        if (version < 1)
+                            m_OutRange = m_RangeCheck;
+
+                        break;
+                    }
+            }
+
+            Timer.DelayCall(TimeSpan.Zero, new TimerCallback(Refresh));
+        }
+    }
+}

Scripts/Items/Internal/PaintedCavesTeleporters.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace Server.Items
+{
+    public class PaintedCavesTele : Teleporter
+    { 
+        [Constructable]
+        public PaintedCavesTele()
+            : base(new Point3D(6308, 892, 0), Map.Trammel)
+        {
+        }
+
+        public PaintedCavesTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (m.NetState == null || !m.NetState.SupportsExpansion(Expansion.ML))
+            {
+                m.SendLocalizedMessage(1072608); // You must upgrade to the Mondain's Legacy expansion in order to enter here.				
+                return true;
+            }
+            else if (!MondainsLegacy.PaintedCaves && (int)m.AccessLevel < (int)AccessLevel.GameMaster)
+            {
+                m.SendLocalizedMessage(1042753, "Painted Caves"); // ~1_SOMETHING~ has been temporarily disabled.
+                return true;
+            }
+			
+            return base.OnMoveOver(m);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/ParoxysmusTeleporters.cs

@@ -0,0 +1,138 @@
+using System;
+
+namespace Server.Items
+{
+    public class ParoxysmusTele : Teleporter
+    { 
+        [Constructable]
+        public ParoxysmusTele()
+            : base(new Point3D(6222, 335, 60), Map.Trammel)
+        {
+        }
+
+        public ParoxysmusTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (m.NetState == null || !m.NetState.SupportsExpansion(Expansion.ML))
+            {
+                m.SendLocalizedMessage(1072608); // You must upgrade to the Mondain's Legacy expansion in order to enter here.				
+                return true;
+            }
+            else if (!MondainsLegacy.PalaceOfParoxysmus && (int)m.AccessLevel < (int)AccessLevel.GameMaster)
+            {
+                m.SendLocalizedMessage(1042753, "Palace of Paroxysmus"); // ~1_SOMETHING~ has been temporarily disabled.
+                return true;
+            }
+		
+            if (m.Backpack != null)
+            {
+                Item rope = m.Backpack.FindItemByType(typeof(MagicalRope), true);
+				
+                if (rope == null)
+                    rope = m.Backpack.FindItemByType(typeof(AcidProofRope), true);
+			
+                if (rope != null && !rope.Deleted)
+                {
+                    if (Utility.RandomDouble() < 0.3)
+                    {
+                        m.SendLocalizedMessage(1075097); // Your rope is severely damaged by the acidic environment.  You're lucky to have made it safely to the ground.
+                        rope.Delete();
+                    }
+                    else
+                        m.SendLocalizedMessage(1075098); // Your rope has been weakened by the acidic environment.
+					
+                    return base.OnMoveOver(m);					
+                }
+            }
+            else
+                m.SendLocalizedMessage(1074272); // You have no way to lower yourself safely into the enormous sinkhole.
+			
+            return true;	
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class ParoxysmusTeleFel : Teleporter
+    {
+        [Constructable]
+        public ParoxysmusTeleFel()
+            : base(new Point3D(6222, 335, 60), Map.Felucca)
+        {
+        }
+
+        public ParoxysmusTeleFel(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (m.NetState == null || !m.NetState.SupportsExpansion(Expansion.ML))
+            {
+                m.SendLocalizedMessage(1072608); // You must upgrade to the Mondain's Legacy expansion in order to enter here.				
+                return true;
+            }
+            else if (!MondainsLegacy.PalaceOfParoxysmus && (int)m.AccessLevel < (int)AccessLevel.GameMaster)
+            {
+                m.SendLocalizedMessage(1042753, "Palace of Paroxysmus"); // ~1_SOMETHING~ has been temporarily disabled.
+                return true;
+            }
+
+            if (m.Backpack != null)
+            {
+                Item rope = m.Backpack.FindItemByType(typeof(MagicalRope), true);
+
+                if (rope == null)
+                    rope = m.Backpack.FindItemByType(typeof(AcidProofRope), true);
+
+                if (rope != null && !rope.Deleted)
+                {
+                    if (Utility.RandomDouble() < 0.3)
+                    {
+                        m.SendLocalizedMessage(1075097); // Your rope is severely damaged by the acidic environment.  You're lucky to have made it safely to the ground.
+                        rope.Delete();
+                    }
+                    else
+                        m.SendLocalizedMessage(1075098); // Your rope has been weakened by the acidic environment.
+
+                    return base.OnMoveOver(m);
+                }
+            }
+            else
+                m.SendLocalizedMessage(1074272); // You have no way to lower yourself safely into the enormous sinkhole.
+
+            return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/PoolOfAcid.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class PoolOfAcid : Item
+    {
+        private readonly TimeSpan m_Duration;
+        private readonly int m_MinDamage;
+        private readonly int m_MaxDamage;
+        private readonly DateTime m_Created;
+        private readonly Timer m_Timer;
+        private bool m_Drying;
+		
+        [Constructable]
+        public PoolOfAcid()
+            : this(TimeSpan.FromSeconds(10.0), 2, 5)
+        {
+        }
+
+        [Constructable]
+        public PoolOfAcid(TimeSpan duration, int minDamage, int maxDamage)
+            : base(0x122A)
+        {
+            Hue = 0x3F;
+            Movable = false;
+            m_MinDamage = minDamage;
+            m_MaxDamage = maxDamage;
+            m_Created = DateTime.UtcNow;
+            m_Duration = duration;
+            m_Timer = Timer.DelayCall(TimeSpan.Zero, TimeSpan.FromSeconds(1), new TimerCallback(OnTick));
+        }
+
+        public PoolOfAcid(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override string DefaultName
+        {
+            get
+            {
+                return "a pool of acid";
+            }
+        }
+        public override void OnAfterDelete()
+        {
+            if (this.m_Timer != null)
+                this.m_Timer.Stop();
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            this.Damage(m);
+            return true;
+        }
+
+        public void Damage(Mobile m)
+        {
+            m.Damage(Utility.RandomMinMax(this.m_MinDamage, this.m_MaxDamage));
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            //Don't serialize these
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+        }
+
+        private void OnTick()
+        {
+            DateTime now = DateTime.UtcNow;
+            TimeSpan age = now - this.m_Created;
+
+            if (age > this.m_Duration)
+            {
+                this.Delete();
+            }
+            else
+            {
+                if (!this.m_Drying && age > (this.m_Duration - age))
+                {
+                    this.m_Drying = true;
+                    this.ItemID = 0x122B;
+                }
+
+                List<Mobile> toDamage = new List<Mobile>();
+                IPooledEnumerable eable = GetMobilesInRange(0);
+
+                foreach (Mobile m in eable)
+                {
+                    BaseCreature bc = m as BaseCreature;
+
+                    if (m.Alive && !m.IsDeadBondedPet && (bc == null || bc.Controlled || bc.Summoned))
+                    {
+                        toDamage.Add(m);
+                    }
+                }
+                eable.Free();
+
+                for (int i = 0; i < toDamage.Count; i++)
+                    this.Damage(toDamage[i]);
+            }
+        }
+    }
+}

Scripts/Items/Internal/PrismOfLightTeleporters.cs

@@ -0,0 +1,162 @@
+using System;
+
+namespace Server.Items
+{
+    public class PrismOfLightTele : Teleporter
+    { 
+        [Constructable]
+        public PrismOfLightTele()
+            : base(new Point3D(6474, 188, 0), Map.Trammel)
+        {
+        }
+
+        public PrismOfLightTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (m.NetState == null || !m.NetState.SupportsExpansion(Expansion.ML))
+            {
+                m.SendLocalizedMessage(1072608); // You must upgrade to the Mondain's Legacy expansion in order to enter here.				
+                return true;
+            }
+            else if (!MondainsLegacy.PrismOfLight && (int)m.AccessLevel < (int)AccessLevel.GameMaster)
+            {
+                m.SendLocalizedMessage(1042753, "Prism of Light"); // ~1_SOMETHING~ has been temporarily disabled.
+                return true;
+            }
+		
+            if (m.Backpack != null)
+            {
+                if (m.Backpack.FindItemByType(typeof(PrismOfLightAdmissionTicket), true) != null)
+                    return base.OnMoveOver(m);
+            }
+			
+            m.SendLocalizedMessage(1074277); // No admission without a ticket.
+			
+            return true;	
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class PrismOfLightTeleFel : Teleporter
+    {
+        [Constructable]
+        public PrismOfLightTeleFel()
+            : base(new Point3D(6474, 188, 0), Map.Felucca)
+        {
+        }
+
+        public PrismOfLightTeleFel(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (m.NetState == null || !m.NetState.SupportsExpansion(Expansion.ML))
+            {
+                m.SendLocalizedMessage(1072608); // You must upgrade to the Mondain's Legacy expansion in order to enter here.				
+                return true;
+            }
+            else if (!MondainsLegacy.PrismOfLight && (int)m.AccessLevel < (int)AccessLevel.GameMaster)
+            {
+                m.SendLocalizedMessage(1042753, "Prism of Light"); // ~1_SOMETHING~ has been temporarily disabled.
+                return true;
+            }
+
+            if (m.Backpack != null)
+            {
+                if (m.Backpack.FindItemByType(typeof(PrismOfLightAdmissionTicket), true) != null)
+                    return base.OnMoveOver(m);
+            }
+
+            m.SendLocalizedMessage(1074277); // No admission without a ticket.
+
+            return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class CrystalFieldTele : Item
+    {
+        [Constructable]
+        public CrystalFieldTele()
+            : base(0x3818)
+        {
+            this.Movable = false;
+        }
+
+        public CrystalFieldTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override TimeSpan DecayTime
+        {
+            get
+            {
+                return TimeSpan.FromMinutes(1);
+            }
+        }
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (m.Player)
+            {
+                if (Utility.RandomBool())
+                {
+                    Point3D p = new Point3D(6523, 71, -10);
+                    Server.Mobiles.BaseCreature.TeleportPets(m, p, m.Map);
+                    m.MoveToWorld(p, m.Map);
+                }
+				
+                this.Delete();
+                return false;
+            }
+            else
+                return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/PvPWarnTeleporter.cs

@@ -0,0 +1,127 @@
+using System;
+using Server;
+using Server.Mobiles;
+using Server.Gumps;
+using Server.Network;
+
+namespace Server.Items
+{
+	public class PvPWarnTeleporter : Teleporter
+	{
+		[Constructable]
+		public PvPWarnTeleporter()
+		{
+		}
+
+		public PvPWarnTeleporter( Serial serial )
+			: base( serial )
+		{
+		}
+
+		public override bool OnMoveOver( Mobile m )
+		{
+			PlayerMobile pm = m as PlayerMobile;
+
+			if ( pm != null )
+			{
+				if ( pm.DisabledPvpWarning )
+					return base.OnMoveOver( m );
+				else if ( !pm.HasGump( typeof( PvpWarningGump ) ) )
+					pm.SendGump( new PvpWarningGump( this ) );
+			}
+
+			return true;
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+
+    public class PvpWarningGump : Gump
+    {
+        private Teleporter m_Owner;
+
+        public PvpWarningGump(Teleporter teleporter)
+            : base(150, 50)
+        {
+            m_Owner = teleporter;
+
+            AddPage(0);
+
+            AddImage(0, 0, 0xE10);
+            AddImageTiled(0, 14, 15, 200, 0xE13);
+            AddImageTiled(380, 14, 14, 200, 0xE15);
+            AddImage(0, 201, 0xE16);
+            AddImageTiled(15, 201, 370, 16, 0xE17);
+            AddImageTiled(15, 0, 370, 16, 0xE11);
+            AddImage(380, 0, 0xE12);
+            AddImage(380, 201, 0xE18);
+            AddImageTiled(15, 15, 365, 190, 0xA40);
+
+            AddHtmlLocalized(30, 20, 330, 20, 1060635, 0x4040FE, false, false); // <CENTER>WARNING</CENTER>
+            AddHtmlLocalized(30, 50, 330, 60, 1113792, 0xFFFFFF, false, false); // You are about to enter a PvP area, where you can be attacked and stolen from by other players. Do you wish to proceed?
+
+            AddHtmlLocalized(65, 125, 300, 25, 1113794, 0xFFFFFF, false, false); // Yes, I wish to proceed
+            AddButton(30, 125, 0xFA5, 0xFA7, 1, GumpButtonType.Reply, 0);
+
+            AddHtmlLocalized(65, 150, 300, 25, 1113795, 0xFFFFFF, false, false); // Yes, and do not ask me again
+            AddButton(30, 150, 0xFA5, 0xFA7, 2, GumpButtonType.Reply, 0);
+
+            AddHtmlLocalized(65, 175, 300, 25, 1113793, 0xFFFFFF, false, false); // No, I do not wish to proceed
+            AddButton(30, 175, 0xFA5, 0xFA7, 0, GumpButtonType.Reply, 0);
+
+            AddImageTiled(15, 14, 365, 1, 0x2393);
+            AddImageTiled(380, 14, 1, 190, 0x2391);
+            AddImageTiled(15, 205, 365, 1, 0x2393);
+            AddImageTiled(15, 14, 1, 190, 0x2391);
+            AddImageTiled(0, 0, 395, 1, 0x23C5);
+            AddImageTiled(394, 0, 1, 217, 0x23C3);
+            AddImageTiled(0, 216, 395, 1, 0x23C5);
+            AddImageTiled(0, 0, 1, 217, 0x23C3);
+        }
+
+        public override void OnResponse(NetState sender, RelayInfo info)
+        {
+            PlayerMobile pm = sender.Mobile as PlayerMobile;
+
+            if (pm == null)
+                return;
+
+            if (!pm.InRange(m_Owner.Location, 5))
+                return;
+
+            switch (info.ButtonID)
+            {
+                case 2: // Yes, and do not ask me again
+                    {
+                        pm.DisabledPvpWarning = true;
+                        pm.SendLocalizedMessage(1113796); // You may use your avatar's context menu to re-enable the warning later.
+
+                        goto case 1;
+                    }
+                case 1: // Yes, I wish to proceed
+                    {
+                        BaseCreature.TeleportPets(pm, m_Owner.PointDest, m_Owner.MapDest);
+                        pm.MoveToWorld(m_Owner.PointDest, m_Owner.MapDest);
+
+                        break;
+                    }
+                case 0: // No, I do not wish to proceed
+                    {
+                        break;
+                    }
+            }
+        }
+    }
+}

Scripts/Items/Internal/ResGate.cs

@@ -0,0 +1,61 @@
+using System;
+using Server.Gumps;
+
+namespace Server.Items
+{
+    public class ResGate : Item
+    {
+        [Constructable]
+        public ResGate()
+            : base(0xF6C)
+        {
+            this.Movable = false;
+            this.Hue = 0x2D1;
+            this.Light = LightType.Circle300;
+        }
+
+        public ResGate(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override string DefaultName
+        {
+            get
+            {
+                return "a resurrection gate";
+            }
+        }
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (!m.Alive && m.Map != null && m.Map.CanFit(m.Location, 16, false, false))
+            {
+                m.PlaySound(0x214);
+                m.FixedEffect(0x376A, 10, 16);
+
+                m.CloseGump(typeof(ResurrectGump));
+                m.SendGump(new ResurrectGump(m));
+            }
+            else
+            {
+                m.SendLocalizedMessage(502391); // Thou can not be resurrected there!
+            }
+
+            return false;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/SanctuaryTele.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace Server.Items
+{
+    public class SanctuaryTele : Teleporter
+    { 
+        [Constructable]
+        public SanctuaryTele()
+            : base(new Point3D(6172, 22, 0), Map.Trammel)
+        {
+        }
+
+        public SanctuaryTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (m.NetState == null || !m.NetState.SupportsExpansion(Expansion.ML))
+            {
+                m.SendLocalizedMessage(1072608); // You must upgrade to the Mondain's Legacy expansion in order to enter here.				
+                return true;
+            }
+            else if (!MondainsLegacy.Sanctuary && (int)m.AccessLevel < (int)AccessLevel.GameMaster)
+            {
+                m.SendLocalizedMessage(1042753, "Sanctuary"); // ~1_SOMETHING~ has been temporarily disabled.
+                return true;
+            }
+			
+            return base.OnMoveOver(m);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/TeleportRope.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Server;
+
+namespace Server.Items
+{
+	public class TeleportRope : Static
+	{
+        public virtual bool AllowDead { get { return true; } }
+
+		[CommandProperty(AccessLevel.Administrator)]
+		public Point3D ToLocation { get; set; }
+
+		[CommandProperty(AccessLevel.Administrator)]
+		public Map ToMap { get; set; }
+
+		[Constructable]
+		public TeleportRope()
+			: base(0x14FA)
+		{
+			ToLocation = Point3D.Zero;
+			ToMap = Map.Internal;
+		}
+
+		public TeleportRope(Serial serial)
+			: base(serial)
+		{ }
+
+		public override void OnDoubleClick(Mobile from)
+		{
+			base.OnDoubleClick(from);
+
+			if (ToLocation == Point3D.Zero ||
+				ToMap == Map.Internal)
+				return;
+
+			from.MoveToWorld(ToLocation, ToMap);
+		}
+
+        public override void OnDoubleClickDead(Mobile from)
+        {
+            if (AllowDead)
+            {
+                OnDoubleClick(from);
+            }
+            else
+            {
+                base.OnDoubleClickDead(from);
+            }
+        }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.Write(0); // Version
+			writer.Write(ToLocation);
+			writer.Write(ToMap);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			int version = reader.ReadInt();
+
+			switch (version)
+			{
+				case 0:
+					ToLocation = reader.ReadPoint3D();
+					ToMap = reader.ReadMap();
+					break;
+			}
+		}
+	}
+}

Scripts/Items/Internal/TwistedWealdTeleporters.cs

@@ -0,0 +1,60 @@
+using System;
+using Server.Engines.Quests;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class TwistedWealdTele : Teleporter
+    { 
+        [Constructable]
+        public TwistedWealdTele()
+            : base(new Point3D(2189, 1253, 0), Map.Ilshenar)
+        {
+        }
+
+        public TwistedWealdTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (m.NetState == null || !m.NetState.SupportsExpansion(Expansion.ML))
+            {
+                m.SendLocalizedMessage(1072608); // You must upgrade to the Mondain's Legacy expansion in order to enter here.				
+                return true;
+            }
+            else if (!MondainsLegacy.TwistedWeald && (int)m.AccessLevel < (int)AccessLevel.GameMaster)
+            {
+                m.SendLocalizedMessage(1042753, "Twisted Weald"); // ~1_SOMETHING~ has been temporarily disabled.
+                return true;
+            }
+			
+            if (m is PlayerMobile)
+            {
+                PlayerMobile player = (PlayerMobile)m;
+				
+                if (QuestHelper.GetQuest(player, typeof(DreadhornQuest)) != null)
+                    return base.OnMoveOver(m);
+				
+                player.SendLocalizedMessage(1074274); // You dance in the fairy ring, but nothing happens.
+            }
+			
+            return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/UnderworldTele.cs

@@ -0,0 +1,46 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{ 
+    public class UnderworldTele : Teleporter
+    { 
+        [Constructable]
+        public UnderworldTele()
+        {
+        }
+
+        public UnderworldTele(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (m is PlayerMobile)
+            {
+                PlayerMobile player = (PlayerMobile)m;
+				
+                if (player.AbyssEntry)
+                {
+                    return base.OnMoveOver(m);
+                }
+                else
+					player.SendLocalizedMessage(1077196); // You may not enter this area.				
+            }
+            return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/UzeraanTurmoilTeleporter.cs

@@ -0,0 +1,73 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Engines.Quests.Haven
+{
+    public class UzeraanTurmoilTeleporter : DynamicTeleporter
+    {
+        [Constructable]
+        public UzeraanTurmoilTeleporter()
+        {
+        }
+
+        public UzeraanTurmoilTeleporter(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool GetDestination(PlayerMobile player, ref Point3D loc, ref Map map)
+        {
+            QuestSystem qs = player.Quest;
+
+            if (qs is UzeraanTurmoilQuest)
+            {
+                if (qs.IsObjectiveInProgress(typeof(FindSchmendrickObjective)) ||
+                    qs.IsObjectiveInProgress(typeof(FindApprenticeObjective)) ||
+                    UzeraanTurmoilQuest.HasLostScrollOfPower(player))
+                {
+                    loc = new Point3D(5222, 1858, 0);
+                    map = Map.Trammel;
+                    return true;
+                }
+                else if (qs.IsObjectiveInProgress(typeof(FindDryadObjective)) ||
+                         UzeraanTurmoilQuest.HasLostFertileDirt(player))
+                {
+                    loc = new Point3D(3557, 2690, 2);
+                    map = Map.Trammel;
+                    return true;
+                }
+                else if (player.Profession != 5 // paladin
+                         &&
+                         (qs.IsObjectiveInProgress(typeof(GetDaemonBoneObjective)) ||
+                          UzeraanTurmoilQuest.HasLostDaemonBone(player)))
+                {
+                    loc = new Point3D(3422, 2653, 48);
+                    map = Map.Trammel;
+                    return true;
+                }
+                else if (qs.IsObjectiveInProgress(typeof(CashBankCheckObjective)))
+                {
+                    loc = new Point3D(3624, 2610, 0);
+                    map = Map.Trammel;
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Items/Internal/WarningItem.cs

@@ -0,0 +1,295 @@
+using System;
+using System.Collections.Generic;
+using Server.Network;
+
+namespace Server.Items
+{
+    public class WarningItem : Item
+    {
+        private string m_WarningString;
+        private int m_WarningNumber;
+        private int m_Range;
+        private TimeSpan m_ResetDelay;
+        private bool m_Broadcasting;
+        private DateTime m_LastBroadcast;
+        [Constructable]
+        public WarningItem(int itemID, int range, int warning)
+            : base(itemID)
+        {
+            if (range > 18)
+                range = 18;
+
+            this.Movable = false;
+
+            this.m_WarningNumber = warning;
+            this.m_Range = range;
+        }
+
+        [Constructable]
+        public WarningItem(int itemID, int range, string warning)
+            : base(itemID)
+        {
+            if (range > 18)
+                range = 18;
+
+            this.Movable = false;
+
+            this.m_WarningString = warning;
+            this.m_Range = range;
+        }
+
+        public WarningItem(Serial serial)
+            : base(serial)
+        {
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public string WarningString
+        {
+            get
+            {
+                return this.m_WarningString;
+            }
+            set
+            {
+                this.m_WarningString = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int WarningNumber
+        {
+            get
+            {
+                return this.m_WarningNumber;
+            }
+            set
+            {
+                this.m_WarningNumber = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int Range
+        {
+            get
+            {
+                return this.m_Range;
+            }
+            set
+            {
+                if (value > 18)
+                    value = 18;
+                this.m_Range = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public TimeSpan ResetDelay
+        {
+            get
+            {
+                return this.m_ResetDelay;
+            }
+            set
+            {
+                this.m_ResetDelay = value;
+            }
+        }
+        public virtual bool OnlyToTriggerer
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public virtual int NeighborRange
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override bool HandlesOnMovement
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public virtual void SendMessage(Mobile triggerer, bool onlyToTriggerer, string messageString, int messageNumber)
+        {
+            if (onlyToTriggerer)
+            {
+                if (messageString != null)
+                    triggerer.SendMessage(messageString);
+                else
+                    triggerer.SendLocalizedMessage(messageNumber);
+            }
+            else
+            {
+                if (messageString != null)
+                    this.PublicOverheadMessage(MessageType.Regular, 0x3B2, false, messageString);
+                else
+                    this.PublicOverheadMessage(MessageType.Regular, 0x3B2, messageNumber);
+            }
+        }
+
+        public virtual void Broadcast(Mobile triggerer)
+        {
+            if (this.m_Broadcasting || (DateTime.UtcNow < (this.m_LastBroadcast + this.m_ResetDelay)))
+                return;
+
+            this.m_LastBroadcast = DateTime.UtcNow;
+
+            this.m_Broadcasting = true;
+
+            this.SendMessage(triggerer, this.OnlyToTriggerer, this.m_WarningString, this.m_WarningNumber);
+
+            if (this.NeighborRange >= 0)
+            {
+                List<WarningItem> list = new List<WarningItem>();
+
+                foreach (Item item in this.GetItemsInRange(this.NeighborRange))
+                {
+                    if (item != this && item is WarningItem)
+                        list.Add((WarningItem)item);
+                }
+
+                for (int i = 0; i < list.Count; i++)
+                    list[i].Broadcast(triggerer);
+            }
+
+            Timer.DelayCall(TimeSpan.Zero, new TimerCallback(InternalCallback));
+        }
+
+        public override void OnMovement(Mobile m, Point3D oldLocation)
+        {
+            if (m.Player && Utility.InRange(m.Location, this.Location, this.m_Range) && !Utility.InRange(oldLocation, this.Location, this.m_Range))
+                this.Broadcast(m);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0);
+
+            writer.Write((string)this.m_WarningString);
+            writer.Write((int)this.m_WarningNumber);
+            writer.Write((int)this.m_Range);
+
+            writer.Write((TimeSpan)this.m_ResetDelay);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 0:
+                    {
+                        this.m_WarningString = reader.ReadString();
+                        this.m_WarningNumber = reader.ReadInt();
+                        this.m_Range = reader.ReadInt();
+                        this.m_ResetDelay = reader.ReadTimeSpan();
+
+                        break;
+                    }
+            }
+        }
+
+        private void InternalCallback()
+        {
+            this.m_Broadcasting = false;
+        }
+    }
+
+    public class HintItem : WarningItem
+    {
+        private string m_HintString;
+        private int m_HintNumber;
+        [Constructable]
+        public HintItem(int itemID, int range, int warning, int hint)
+            : base(itemID, range, warning)
+        {
+            this.m_HintNumber = hint;
+        }
+
+        [Constructable]
+        public HintItem(int itemID, int range, string warning, string hint)
+            : base(itemID, range, warning)
+        {
+            this.m_HintString = hint;
+        }
+
+        public HintItem(Serial serial)
+            : base(serial)
+        {
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public string HintString
+        {
+            get
+            {
+                return this.m_HintString;
+            }
+            set
+            {
+                this.m_HintString = value;
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int HintNumber
+        {
+            get
+            {
+                return this.m_HintNumber;
+            }
+            set
+            {
+                this.m_HintNumber = value;
+            }
+        }
+        public override bool OnlyToTriggerer
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void OnDoubleClick(Mobile from)
+        {
+            this.SendMessage(from, true, this.m_HintString, this.m_HintNumber);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0);
+
+            writer.Write((string)this.m_HintString);
+            writer.Write((int)this.m_HintNumber);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 0:
+                    {
+                        this.m_HintString = reader.ReadString();
+                        this.m_HintNumber = reader.ReadInt();
+
+                        break;
+                    }
+            }
+        }
+    }
+}

Scripts/Items/Internal/Waypoint.cs

@@ -0,0 +1,163 @@
+using System;
+using Server.Commands;
+using Server.Targeting;
+
+namespace Server.Items
+{
+    [FlipableAttribute(0x1f14, 0x1f15, 0x1f16, 0x1f17)]
+    public class WayPoint : Item
+    {
+        private WayPoint m_Next;
+        [Constructable]
+        public WayPoint()
+            : base(0x1f14)
+        {
+            this.Hue = 0x498;
+            this.Visible = false;
+            //this.Movable = false;
+        }
+
+        public WayPoint(WayPoint prev)
+            : this()
+        {
+            if (prev != null)
+                prev.NextPoint = this;
+        }
+
+        public WayPoint(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override string DefaultName
+        {
+            get
+            {
+                return "AI Way Point";
+            }
+        }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public WayPoint NextPoint
+        {
+            get
+            {
+                return this.m_Next;
+            }
+            set
+            {
+                if (this.m_Next != this)
+                    this.m_Next = value;
+            }
+        }
+        public static void Initialize()
+        {
+            CommandSystem.Register("WayPointSeq", AccessLevel.GameMaster, new CommandEventHandler(WayPointSeq_OnCommand));
+        }
+
+        public static void WayPointSeq_OnCommand(CommandEventArgs arg)
+        {
+            arg.Mobile.SendMessage("Target the position of the first way point.");
+            arg.Mobile.Target = new WayPointSeqTarget(null);
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (from.AccessLevel >= AccessLevel.GameMaster)
+            {
+                from.SendMessage("Target the next way point in the sequence.");
+
+                from.Target = new NextPointTarget(this);
+            }
+        }
+
+        public override void OnSingleClick(Mobile from)
+        {
+            base.OnSingleClick(from);
+
+            if (this.m_Next == null)
+                this.LabelTo(from, "(Unlinked)");
+            else
+                this.LabelTo(from, "(Linked: {0})", this.m_Next.Location);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch( version )
+            {
+                case 0:
+                    {
+                        this.m_Next = reader.ReadItem() as WayPoint;
+                        break;
+                    }
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0);
+
+            writer.Write(this.m_Next);
+        }
+    }
+
+    public class NextPointTarget : Target
+    {
+        private readonly WayPoint m_Point;
+        public NextPointTarget(WayPoint pt)
+            : base(-1, false, TargetFlags.None)
+        {
+            this.m_Point = pt;
+        }
+
+        protected override void OnTarget(Mobile from, object target)
+        {
+            if (target is WayPoint && this.m_Point != null)
+            {
+                this.m_Point.NextPoint = (WayPoint)target;
+            }
+            else
+            {
+                from.SendMessage("Target a way point.");
+            }
+        }
+    }
+
+    public class WayPointSeqTarget : Target
+    {
+        private readonly WayPoint m_Last;
+        public WayPointSeqTarget(WayPoint last)
+            : base(-1, true, TargetFlags.None)
+        {
+            this.m_Last = last;
+        }
+
+        protected override void OnTarget(Mobile from, object targeted)
+        {
+            if (targeted is WayPoint)
+            {
+                if (this.m_Last != null)
+                    this.m_Last.NextPoint = (WayPoint)targeted;
+            }
+            else if (targeted is IPoint3D)
+            {
+                Point3D p = new Point3D((IPoint3D)targeted);
+
+                WayPoint point = new WayPoint(this.m_Last);
+                point.MoveToWorld(p, from.Map);
+
+                from.Target = new WayPointSeqTarget(point);
+                from.SendMessage("Target the position of the next way point in the sequence, or target a way point link the newest way point to.");
+            }
+            else
+            {
+                from.SendMessage("Target a position, or another way point.");
+            }
+        }
+    }
+}

Scripts/Items/Internal/WhiteNinjaQuestTeleporter.cs

@@ -0,0 +1,70 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Engines.Quests.Ninja
+{
+    public class WhiteNinjaQuestTeleporter : DynamicTeleporter
+    {
+        [Constructable]
+        public WhiteNinjaQuestTeleporter()
+            : base(0x51C, 0x47E)
+        {
+        }
+
+        public WhiteNinjaQuestTeleporter(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1026157;
+            }
+        }// teleporter
+        public override int NotWorkingMessage
+        {
+            get
+            {
+                return 1063198;
+            }
+        }// You stand on the strange floor tile but nothing happens.
+        public override bool GetDestination(PlayerMobile player, ref Point3D loc, ref Map map)
+        {
+            QuestSystem qs = player.Quest;
+
+            if (qs is EminosUndertakingQuest)
+            {
+                QuestObjective obj = qs.FindObjective(typeof(SearchForSwordObjective));
+
+                if (obj != null)
+                {
+                    if (!obj.Completed)
+                        obj.Complete();
+
+                    loc = new Point3D(411, 1085, 0);
+                    map = Map.Malas;
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}