Overwrite

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

Scripts/Services/Revamped Dungeons/WrongDungeon/EnchantedHotItem.cs

@@ -0,0 +1,184 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using System.Linq;
+using System.IO;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public static class EnchantedHotItem
+    {
+        public static string FilePath = Path.Combine("Saves/Misc", "EnchantedHotItem.bin");
+
+        public static void Configure()
+        {
+            EventSink.WorldSave += OnSave;
+            EventSink.WorldLoad += OnLoad;
+        }
+
+        public static void OnSave(WorldSaveEventArgs e)
+        {
+            Persistence.Serialize(
+                FilePath,
+                writer =>
+                {
+                    writer.Write(1);
+                });
+        }
+
+        public static void OnLoad()
+        {
+            Persistence.Deserialize(
+                FilePath,
+                reader =>
+                {
+                    int version = reader.ReadInt();
+
+                    if (version == 0)
+                    {
+                        int count = reader.ReadInt();
+
+                        for (int i = 0; i < count; i++)
+                        {
+                            Item item = reader.ReadItem();
+                            Container c = reader.ReadItem() as Container;
+
+                            if (item != null && c != null)
+                            {
+                                item.AttachSocket(new EnchantedHotItemSocket(c));
+                            }
+                        }
+                    }
+                });
+        }
+
+        public static Point3D[] ChestLocs = 
+        {
+            new Point3D(5703, 664, 0), new Point3D(5703, 663, 0), new Point3D(5703, 662, 0), new Point3D(5703, 661, 0),
+            new Point3D(5707, 659, 0), new Point3D(5708, 659, 0), new Point3D(5709, 659, 0)
+        };
+
+        public static void SpawnChests(Map map)
+        {
+            IPooledEnumerable eable = map.GetItemsInRange(new Point3D(5707, 662, 0), 15);
+
+            foreach (Item item in eable)
+            {
+                if (item is MetalGoldenChest)
+                {
+                    item.Delete();
+                }
+            }
+
+            eable.Free();
+
+            for (int i = 0; i < ChestLocs.Length; i++)
+            {
+                var chest = new HotItemChest(i <= 3 ? 3648 : 3649);
+
+                chest.MoveToWorld(ChestLocs[i], map);
+                chest.SpawnLoot();
+            }
+        }
+    }
+
+    public class HotItemChest : LockableContainer
+    {
+        public HotItemChest(int itemID) 
+            : base(itemID)
+        {
+            Movable = false;
+            RequiredSkill = 92;
+            LockLevel = RequiredSkill - Utility.Random(1, 10);
+            MaxLockLevel = RequiredSkill;
+
+            LiftOverride = true;
+            Locked = true;
+        }
+
+        public void SpawnLoot()
+        {
+            List<Item> list = new List<Item>(Items);
+
+            foreach (var item in list)
+                item.Delete();
+
+            ColUtility.Free(list);
+
+            int toSpawn = Utility.RandomMinMax(2, 4);
+
+            for (int i = 0; i < toSpawn; i++)
+            {
+                Item item;
+
+                if (i == 0)
+                {
+                    item = Loot.RandomScroll(0, Loot.RegularScrollTypes.Length, SpellbookType.Regular);
+                }
+                else
+                {
+                    item = Loot.RandomArmorOrShieldOrWeaponOrJewelry(false, false, true);
+
+                    if (item is BaseWeapon && 0.01 > Utility.RandomDouble())
+                    {
+                        ((BaseWeapon)item).ExtendedWeaponAttributes.AssassinHoned = 1;
+                    }
+
+                    int min = 400;
+                    int max = 1400;
+
+                    RunicReforging.GenerateRandomItem(item, 0, min, max, this.Map);
+
+                    item.Hue = 1258;
+                    item.AttachSocket(new EnchantedHotItemSocket(this));
+                    //EnchantedHotItem.AddItem(item, this);
+                }
+
+                DropItem(item);
+            }
+        }
+
+        public override void LockPick(Mobile from)
+        {
+            base.LockPick(from);
+
+            Timer.DelayCall(TimeSpan.FromMinutes(10), () =>
+                {
+                    Visible = false;
+                    Visible = true;
+
+                    Locked = true;
+
+                    SpawnLoot();
+                });
+        }
+
+        public HotItemChest(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();
+
+            if (!Locked)
+            {
+                Timer.DelayCall(TimeSpan.FromMinutes(5), () =>
+                {
+                    Locked = true;
+                });
+            }
+        }
+    }
+}

Scripts/Services/Revamped Dungeons/WrongDungeon/Generate.cs

@@ -0,0 +1,117 @@
+using Server;
+using Server.Commands;
+using Server.Items;
+using Server.Mobiles;
+using System.Linq;
+
+namespace Server.Engines
+{
+    public static class GenerateWrongRevamp
+    {
+        public static void Initialize()
+        {
+            CommandSystem.Register("GenWrongRevamp", AccessLevel.Administrator, Generate_NewWrong);
+        }        
+
+        public static void Generate_NewWrong(CommandEventArgs e)
+        {
+            DeleteOldWrong(e.Mobile);
+
+            CommandSystem.Handle(e.Mobile, Server.Commands.CommandSystem.Prefix + "XmlLoad RevampedSpawns/WrongRevamped.xml");
+
+            Decorate.Generate("wrong", "Data/Decoration/Wrong", Map.Trammel, Map.Felucca);
+
+            Item spawner = new BedrollSpawner();
+            spawner.MoveToWorld(new Point3D(5823, 601, 0), Map.Felucca);
+
+            spawner = new BedrollSpawner();
+            spawner.MoveToWorld(new Point3D(5823, 601, 0), Map.Trammel);
+
+            EnchantedHotItem.SpawnChests(Map.Trammel);
+            EnchantedHotItem.SpawnChests(Map.Felucca);
+
+            Teleporter teleporter = new Teleporter(new Point3D(5690, 569, 25), Map.Felucca);
+            teleporter.MoveToWorld(new Point3D(5827, 590, 1), Map.Felucca);
+
+            teleporter = new Teleporter(new Point3D(5829, 595, 0), Map.Felucca);
+            teleporter.MoveToWorld(new Point3D(5690, 573, 25), Map.Felucca);
+
+            teleporter = new Teleporter(new Point3D(5690, 569, 25), Map.Felucca);
+            teleporter.MoveToWorld(new Point3D(5872, 532, 24), Map.Felucca);
+
+            teleporter = new Teleporter(new Point3D(5827, 593, 0), Map.Felucca);
+            teleporter.MoveToWorld(new Point3D(5732, 554, 24), Map.Felucca);
+
+            teleporter = new Teleporter(new Point3D(5703, 639, 0), Map.Felucca);
+            teleporter.MoveToWorld(new Point3D(5708, 625, 0), Map.Felucca);
+
+            teleporter = new Teleporter(new Point3D(5792, 526, 10), Map.Felucca);
+            teleporter.MoveToWorld(new Point3D(5698, 662, 0), Map.Felucca);
+
+            teleporter = new Teleporter(new Point3D(2041, 215, 14), Map.Felucca);
+            teleporter.MoveToWorld(new Point3D(5824, 631, 5), Map.Felucca);
+
+            teleporter = new Teleporter(new Point3D(2043, 215, 14), Map.Felucca);
+            teleporter.MoveToWorld(new Point3D(5825, 631, 5), Map.Felucca);
+
+            teleporter = new Teleporter(new Point3D(5690, 569, 25), Map.Trammel);
+            teleporter.MoveToWorld(new Point3D(5827, 590, 1), Map.Trammel);
+
+            teleporter = new Teleporter(new Point3D(5829, 595, 0), Map.Trammel);
+            teleporter.MoveToWorld(new Point3D(5690, 573, 25), Map.Trammel);
+
+            teleporter = new Teleporter(new Point3D(5690, 569, 25), Map.Trammel);
+            teleporter.MoveToWorld(new Point3D(5872, 532, 24), Map.Trammel);
+
+            teleporter = new Teleporter(new Point3D(5827, 593, 0), Map.Trammel);
+            teleporter.MoveToWorld(new Point3D(5732, 554, 24), Map.Trammel);
+
+            teleporter = new Teleporter(new Point3D(5703, 639, 0), Map.Trammel);
+            teleporter.MoveToWorld(new Point3D(5708, 625, 0), Map.Trammel);
+
+            teleporter = new Teleporter(new Point3D(5792, 526, 10), Map.Trammel);
+            teleporter.MoveToWorld(new Point3D(5698, 662, 0), Map.Trammel);
+
+            teleporter = new Teleporter(new Point3D(2041, 215, 14), Map.Trammel);
+            teleporter.MoveToWorld(new Point3D(5824, 631, 5), Map.Trammel);
+
+            teleporter = new Teleporter(new Point3D(2043, 215, 14), Map.Trammel);
+            teleporter.MoveToWorld(new Point3D(5825, 631, 5), Map.Trammel);
+
+            e.Mobile.SendMessage("Wrong Revamp generation complete.");
+        }
+
+        public static void DeleteOldWrong(Mobile m)
+        {
+            int count = 0;
+
+            IPooledEnumerable eable = Map.Felucca.GetItemsInBounds(new Rectangle2D(5633, 511, 253, 510));
+
+            foreach (Item item in eable)
+            {
+                if (item is XmlSpawner || item is Teleporter || item.ItemID == 0x375A || item is BarredMetalDoor || item is SecretDungeonDoor)
+                {
+                    count++;
+                    item.Delete();
+                }
+            }
+
+            eable.Free();
+
+            eable = Map.Trammel.GetItemsInBounds(new Rectangle2D(5633, 511, 253, 510));
+
+            foreach (Item item in eable)
+            {
+                if (item is XmlSpawner || item is Teleporter || item.ItemID == 0x375A || item is BarredMetalDoor || item is SecretDungeonDoor)
+                {
+                    count++;
+                    item.Delete();
+                }
+            }
+
+            eable.Free();
+
+            m.SendMessage("{0} items deleted.", count);
+        }
+    }
+}

Scripts/Services/Revamped Dungeons/WrongDungeon/Items/Artifacts/BlanketOfDarknessArtifact.cs

@@ -0,0 +1,139 @@
+using System;
+using Server;
+using Server.Gumps;
+using Server.Mobiles;
+using Server.Network;
+
+namespace Server.Items
+{
+    public class BlanketOfDarkness : Item
+    {
+        public override bool IsArtifact { get { return true; } }
+        public override int LabelNumber { get { return 1152304; } } // Blanket Of Darkness	
+
+        [Constructable]
+        public BlanketOfDarkness()
+            : base(0xA57)
+        {
+            Hue = 2076;
+            Weight = 10.0;
+        }
+
+        public BlanketOfDarkness(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (this.Parent != null || !this.VerifyMove(from))
+                return;
+
+            if (!from.InRange(this, 2))
+            {
+                from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1019045); // I can't reach that.
+                return;
+            }
+
+            if (this.ItemID == 0xA57) // rolled
+            {
+                Direction dir = PlayerMobile.GetDirection4(from.Location, this.Location);
+
+                if (dir == Direction.North || dir == Direction.South)
+                    this.ItemID = 0xA55;
+                else
+                    this.ItemID = 0xA56;
+            }
+            else // unrolled
+            {
+                this.ItemID = 0xA57;
+
+                if (!from.HasGump(typeof(LogoutGump)))
+                {
+                    CampfireEntry entry = Campfire.GetEntry(from);
+
+                    if (entry != null && entry.Safe)
+                        from.SendGump(new LogoutGump(entry, this));
+                }
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1061078, "8"); // artifact rarity ~1_val~
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadEncodedInt();
+        }
+
+        private class LogoutGump : Gump
+        {
+            private readonly Timer m_CloseTimer;
+            private readonly CampfireEntry m_Entry;
+            private readonly BlanketOfDarkness m_BlanketOfDarkness;
+            public LogoutGump(CampfireEntry entry, BlanketOfDarkness BlanketOfDarkness)
+                : base(100, 0)
+            {
+                this.m_Entry = entry;
+                this.m_BlanketOfDarkness = BlanketOfDarkness;
+
+                this.m_CloseTimer = Timer.DelayCall(TimeSpan.FromSeconds(10.0), new TimerCallback(CloseGump));
+
+                this.AddBackground(0, 0, 400, 350, 0xA28);
+
+                this.AddHtmlLocalized(100, 20, 200, 35, 1011015, false, false); // <center>Logging out via camping</center>
+
+                /* Using a bedroll in the safety of a camp will log you out of the game safely.
+                * If this is what you wish to do choose CONTINUE and you will be logged out.
+                * Otherwise, select the CANCEL button to avoid logging out at this time.
+                * The camp will remain secure for 10 seconds at which time this window will close
+                * and you not be logged out.
+                */
+                this.AddHtmlLocalized(50, 55, 300, 140, 1011016, true, true);
+
+                this.AddButton(45, 298, 0xFA5, 0xFA7, 1, GumpButtonType.Reply, 0);
+                this.AddHtmlLocalized(80, 300, 110, 35, 1011011, false, false); // CONTINUE
+
+                this.AddButton(200, 298, 0xFA5, 0xFA7, 0, GumpButtonType.Reply, 0);
+                this.AddHtmlLocalized(235, 300, 110, 35, 1011012, false, false); // CANCEL
+            }
+
+            public override void OnResponse(NetState sender, RelayInfo info)
+            {
+                PlayerMobile pm = this.m_Entry.Player;
+
+                this.m_CloseTimer.Stop();
+
+                if (Campfire.GetEntry(pm) != this.m_Entry)
+                    return;
+
+                if (info.ButtonID == 1 && this.m_Entry.Safe && this.m_BlanketOfDarkness.Parent == null && this.m_BlanketOfDarkness.IsAccessibleTo(pm) &&
+                    this.m_BlanketOfDarkness.VerifyMove(pm) && this.m_BlanketOfDarkness.Map == pm.Map && pm.InRange(this.m_BlanketOfDarkness, 2))
+                {
+                    pm.PlaceInBackpack(this.m_BlanketOfDarkness);
+
+                    pm.BlanketOfDarknessLogout = true;
+                    sender.Dispose();
+                }
+
+                Campfire.RemoveEntry(this.m_Entry);
+            }
+
+            private void CloseGump()
+            {
+                Campfire.RemoveEntry(this.m_Entry);
+                this.m_Entry.Player.CloseGump(typeof(LogoutGump));
+            }
+        }
+    }
+}

Scripts/Services/Revamped Dungeons/WrongDungeon/Items/Artifacts/TortureRackArtifact.cs

@@ -0,0 +1,164 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class TortureRackComponent : AddonComponent, IArtifact
+    {
+        public override int LabelNumber { get { return 1152307; } } // Torture Rack	
+        public virtual bool ShowArtifactRarity { get { return true; } }
+
+        public TortureRackComponent(int itemID)
+            : base(itemID)
+        {
+        }
+
+        public TortureRackComponent(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool ForceShowProperties { get { return ObjectPropertyList.Enabled; } }
+        public virtual int ArtifactRarity { get { return 10; } }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            if (ShowArtifactRarity)
+                list.Add(1061078, this.ArtifactRarity.ToString()); // artifact rarity ~1_val~
+        }
+
+        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 TortureRackEast : BaseAddon
+    {
+        [Constructable]
+        public TortureRackEast()
+        {
+            this.AddComponent(new TortureRackComponent(0x4AAB), 0, 0, 0);
+            this.AddComponent(new TortureRackComponent(0x4AA3), 0, 1, 0);
+            this.AddComponent(new TortureRackComponent(0x4AA2), 0, 2, 0);
+        }
+
+        public TortureRackEast(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override BaseAddonDeed Deed { get { return new TortureRackEastDeed(); } }        
+
+        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 TortureRackEastDeed : BaseAddonDeed
+    {
+        public override int LabelNumber { get { return 1152305; } }
+
+        [Constructable]
+        public TortureRackEastDeed()
+        {
+        }
+
+        public TortureRackEastDeed(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override BaseAddon Addon { get { return new TortureRackEast(); } }
+        
+        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 TortureRackSouth : BaseAddon
+    {
+        [Constructable]
+        public TortureRackSouth()
+        {
+            this.AddComponent(new TortureRackComponent(0x4AA0), 0, 0, 0);
+            this.AddComponent(new TortureRackComponent(0x4AA1), 1, 0, 0);
+            this.AddComponent(new TortureRackComponent(0x4AAD), 2, 0, 0);
+        }
+
+        public TortureRackSouth(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override BaseAddonDeed Deed { get { return new TortureRackSouthDeed(); } }
+
+        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 TortureRackSouthDeed : BaseAddonDeed
+    {
+        public override int LabelNumber { get { return 1152306; } }
+
+        [Constructable]
+        public TortureRackSouthDeed()
+        {
+        }
+
+        public TortureRackSouthDeed(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override BaseAddon Addon { get { return new TortureRackSouth(); } }
+
+        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/Services/Revamped Dungeons/WrongDungeon/Items/BedrollSpawner.cs

@@ -0,0 +1,345 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Server.Items
+{
+    public class BedrollSpawner : Item
+    {
+        public static Point3D[] m_RoomDestinations = new Point3D[]
+        {
+            new Point3D(5651, 555, 20),
+            new Point3D(5658, 562, 20),
+            new Point3D(5666, 558, 20),
+            new Point3D(5793, 594, 10),
+            new Point3D(5790, 587, 10),
+            new Point3D(5789, 579, 10),
+            new Point3D(5790, 571, 10),
+            new Point3D(5793, 563, 10),
+            new Point3D(5792, 555, 10),
+            new Point3D(5863, 594, 15),
+            new Point3D(5864, 585, 15),
+            new Point3D(5864, 578, 15),
+            new Point3D(5863, 570, 15),
+            new Point3D(5865, 562, 15),
+            new Point3D(5868, 554 ,15)
+        };
+
+        public static Point3D[] m_OutsideTunnels = new Point3D[]
+        {
+            new Point3D(5670, 550, 22),
+            new Point3D(5721, 550, 20),
+            new Point3D(5670, 535, 0),
+            new Point3D(5864, 532, 15),
+            new Point3D(5782, 536, 10)
+        };
+
+        private static readonly BedrollEntry[] m_Entries = new BedrollEntry[]
+        {
+            // Upper Floor Room 1
+            new BedrollEntry(new Point3D(5653, 565, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5651, 564, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5653, 561, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5650, 560, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5651, 555, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5651, 557, 20), typeof(WrongBedrollEast)),
+
+            // Upper Floor Room 2
+            new BedrollEntry(new Point3D(5657, 554, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5659, 555, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5661, 558, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5657, 559, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5657, 561, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5660, 561, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5658, 563, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5657, 565, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5661, 563, 20), typeof(WrongBedrollEast)),
+                     
+            // Upper Floor Room 3
+            new BedrollEntry(new Point3D(5666, 554, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5665, 557, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5668, 558, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5665, 560, 20), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5668, 563, 20), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5665, 565, 20), typeof(WrongBedrollEast)),
+
+            // Left Room 1
+            new BedrollEntry(new Point3D(5787, 594, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5789, 596, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5792, 596, 10), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5792, 593, 10), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5795, 596, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5795, 593, 10), typeof(WrongBedrollEast)),
+
+            // Left Room 2
+            new BedrollEntry(new Point3D(5787, 588, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5790, 589, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5791, 585, 10), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5793, 589, 10), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5795, 585, 10), typeof(WrongBedrollEast)),
+
+            // Left Room 3
+            new BedrollEntry(new Point3D(5787, 581, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5791, 577, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5793, 581, 10), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5795, 579, 10), typeof(WrongBedrollSouth)),
+
+            // Left Room 4
+            new BedrollEntry(new Point3D(5787, 570, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5789, 573, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5792, 573, 10), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5792, 570, 10), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5795, 570, 10), typeof(WrongBedrollSouth)),
+
+            // Left Room 5
+            new BedrollEntry(new Point3D(5787, 561, 10), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5788, 564, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5790, 562, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5791, 565, 10), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5795, 565, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5795, 561, 10), typeof(WrongBedrollEast)),
+
+            // Left Room 6
+            new BedrollEntry(new Point3D(5789, 553, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5790, 555, 10), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5791, 557, 10), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5794, 557, 10), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5795, 554, 10), typeof(WrongBedrollSouth)),
+
+            // Rigth Room 1
+            new BedrollEntry(new Point3D(5861, 596, 15), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5862, 593, 15), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5865, 596, 15), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5866, 594, 15), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5867, 592, 15), typeof(WrongBedrollEast)),
+
+            // Rigth Room 2
+            new BedrollEntry(new Point3D(5860, 585, 15), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5861, 588, 15), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5864, 588, 15), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5866, 585, 15), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5867, 588, 15), typeof(WrongBedrollSouth)),
+
+            // Rigth Room 3
+            new BedrollEntry(new Point3D(5860, 577, 15), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5861, 580, 15), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5863, 580, 15), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5864, 576, 15), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5866, 579, 15), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5867, 576, 15), typeof(WrongBedrollEast)),
+
+            // Rigth Room 4
+            new BedrollEntry(new Point3D(5860, 568, 15), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5861, 572, 15), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5863, 569, 15), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5865, 571, 15), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5867, 568, 15), typeof(WrongBedrollSouth)),
+
+            // Rigth Room 5
+            new BedrollEntry(new Point3D(5860, 562, 15), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5861, 560, 15), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5862, 564, 15), typeof(WrongBedrollSouth)),
+            new BedrollEntry(new Point3D(5864, 563, 15), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5864, 561, 15), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5866, 564, 15), typeof(WrongBedrollEast)),
+            new BedrollEntry(new Point3D(5867, 561, 15), typeof(WrongBedrollEast)),
+        };
+
+        public readonly TimeSpan RestartDelay = TimeSpan.FromHours(2.0);
+        private Timer m_Timer;
+        private List<WrongBedrollBase> Bedrolls { get; set; }
+        public List<MysteriousTunnel> MysteriousTunnels { get; set; }
+
+        public static List<BedrollSpawner> Instances { get; set; }
+
+        public BedrollSpawner()
+            : base(3796)
+        {
+            Movable = false;
+            Visible = false;
+            Bedrolls = new List<WrongBedrollBase>();
+            MysteriousTunnels = new List<MysteriousTunnel>();            
+            Timer.DelayCall(TimeSpan.FromSeconds(10), CheckRespawn);
+            m_Timer = Timer.DelayCall(RestartDelay, RestartDelay, new TimerCallback(CheckRespawn));
+            m_Timer.Start();
+
+            if (Instances == null)
+                Instances = new List<BedrollSpawner>();
+
+            Instances.Add(this);
+        }        
+
+        private void CheckRespawn()
+        {
+            Cleanup();
+
+            // Bedrolls Spawn
+
+            foreach (BedrollEntry entry in m_Entries)
+            {
+                WrongBedrollBase item = (WrongBedrollBase)Activator.CreateInstance(entry.Type);
+
+                item.Movable = false;
+                item.MoveToWorld(entry.Location, Map);
+                Bedrolls.Add(item);
+            }
+
+            // Mysterious Tunnels Spawn   
+
+            MysteriousTunnel mt;
+            WrongBedrollBase bedroll;
+            int mtrandom;
+
+            for (int i = 0; i < m_OutsideTunnels.Length; i++)
+            {
+                mt = new MysteriousTunnel();
+
+                if (i < 3)
+                {
+                    mtrandom = Utility.Random(m_Entries.Length);
+                    mt.PointDest = Bedrolls[mtrandom].Location;
+                    Bedrolls[mtrandom].PointDest = m_OutsideTunnels[i];
+                    Bedrolls[mtrandom].BedrollSpawner = this;
+                }
+                else
+                {
+                    mt.PointDest = m_RoomDestinations[Utility.Random(m_RoomDestinations.Length)];
+                    bedroll = Bedrolls.Where(x => x.InRange(mt.PointDest, 4) && x.PointDest == Point3D.Zero).FirstOrDefault();
+
+                    if (bedroll != null)
+                    {
+                        bedroll.PointDest = m_OutsideTunnels[i];
+                        bedroll.BedrollSpawner = this;
+                    }
+                }
+
+                mt.MoveToWorld(m_OutsideTunnels[i], Map);
+                MysteriousTunnels.Add(mt);
+            }            
+        }
+
+        public BedrollSpawner(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public void Cleanup()
+        {
+            if (Bedrolls != null)
+            {
+                Bedrolls.ForEach(f => f.Delete());
+                Bedrolls.Clear();
+            }
+
+            if (MysteriousTunnels != null)
+            {
+                MysteriousTunnels.ForEach(f => f.Delete());
+                MysteriousTunnels.Clear();
+            }
+        }
+
+        public override void OnDelete()
+        {
+            if (m_Timer != null)
+            {
+                m_Timer.Stop();
+                m_Timer = null;
+            }
+
+            Cleanup();
+
+            base.OnDelete();
+        }
+
+        public override string DefaultName { get { return "Wrong Bedrolls Spawner " + Map; } }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(1);
+
+            if (m_Timer != null)
+                writer.Write(m_Timer.Next);
+            else
+                writer.Write(DateTime.UtcNow + RestartDelay);
+
+            writer.Write(Bedrolls == null ? 0 : Bedrolls.Count);
+
+            if (Bedrolls != null)
+            {
+                Bedrolls.ForEach(x => writer.Write(x));
+            }
+
+            writer.Write(MysteriousTunnels == null ? 0 : MysteriousTunnels.Count);
+
+            if (MysteriousTunnels != null)
+            {
+                MysteriousTunnels.ForEach(y => writer.Write(y));
+            }
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (Instances == null)
+                Instances = new List<BedrollSpawner>();
+
+            Instances.Add(this);
+
+            DateTime next = reader.ReadDateTime();
+
+            if (next < DateTime.UtcNow)
+                next = DateTime.UtcNow;
+
+            m_Timer = Timer.DelayCall(next - DateTime.UtcNow, RestartDelay, new TimerCallback(CheckRespawn));
+            m_Timer.Start();
+
+            Bedrolls = new List<WrongBedrollBase>();
+            MysteriousTunnels = new List<MysteriousTunnel>();
+
+            int bedrollcount = reader.ReadInt();
+            for (int x = 0; x < bedrollcount; x++)
+            {
+                WrongBedrollBase wb = reader.ReadItem() as WrongBedrollBase;
+
+                if (wb != null)
+                    Bedrolls.Add(wb);
+            }
+
+            int mysteriouscount = reader.ReadInt();
+            for (int y = 0; y < mysteriouscount; y++)
+            {
+                MysteriousTunnel mt = reader.ReadItem() as MysteriousTunnel;
+
+                if (mt != null)
+                    MysteriousTunnels.Add(mt);
+            }
+
+            if (version == 0)
+            {
+                Timer.DelayCall<Map>(TimeSpan.FromSeconds(5), map => 
+                    {
+                        EnchantedHotItem.SpawnChests(map);
+                        Console.WriteLine("Hot Item chests spawned for {0}.", this.Map);
+                    }, Map);
+            }
+        }
+
+        public class BedrollEntry
+        {
+            private readonly Point3D m_Location;
+            private readonly Type m_Type;
+
+            public BedrollEntry(Point3D location, Type type)
+            {
+                m_Location = location;
+                m_Type = type;
+            }
+
+            public Point3D Location { get { return m_Location; } }
+            public Type Type { get { return m_Type; } }
+        }
+    }
+}

Scripts/Services/Revamped Dungeons/WrongDungeon/Items/MysteriousTunnel.cs

@@ -0,0 +1,60 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class MysteriousTunnel : Item
+    {
+        public override int LabelNumber { get { return 1152265; } } // mysterious tunnel       
+        private Point3D m_PointDest;
+        
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Point3D PointDest
+        {
+            get { return m_PointDest; }
+            set { m_PointDest = value; }
+        }
+
+        [Constructable]
+        public MysteriousTunnel()
+            : base(0x1B71)
+        {
+            this.Movable = false;
+        }
+
+        public MysteriousTunnel(Serial serial)
+            : base(serial)
+        {
+        }        
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (m is PlayerMobile)
+            {
+                Point3D loc = PointDest;
+                m.MoveToWorld(loc, this.Map);
+                BaseCreature.TeleportPets(m, loc, this.Map);
+
+                return false;              
+            }
+
+            return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+
+            writer.Write(this.m_PointDest);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            this.m_PointDest = reader.ReadPoint3D();
+        }
+    }
+}

Scripts/Services/Revamped Dungeons/WrongDungeon/Items/Soap.cs

@@ -0,0 +1,42 @@
+using System;
+
+namespace Server.Items
+{
+    public class Soap : Item
+    {
+        public override int LabelNumber { get { return 1152267; } } // soap
+
+        [Constructable]
+        public Soap()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public Soap(int amount)
+            : base(0x1422)
+        {
+            this.Hue = 1285;
+            this.Weight = 1.0;
+            this.Stackable = true;
+            this.Amount = amount;
+        }
+
+        public Soap(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/Services/Revamped Dungeons/WrongDungeon/Items/StinkingCauldron.cs

@@ -0,0 +1,57 @@
+using System;
+using Server;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class StinkingCauldron : Item
+    {
+        public override int LabelNumber { get { return 1152163; } } // stinking cauldron
+
+        [Constructable]
+        public StinkingCauldron()
+            : base(0x142A)
+        {
+            Movable = false;
+            Hue = 363;
+            Weight = 0.0;
+            Timer.DelayCall(TimeSpan.FromSeconds(10), new TimerCallback(GooeyMaggotsSpawn));
+        }
+
+        private void GooeyMaggotsSpawn()
+        {
+            if (Map != null && Map != Map.Internal)
+            {
+                int amount = Utility.RandomMinMax(1, 2);
+
+                for (int i = 0; i < amount; ++i)
+                {
+                    BaseCreature creature = new GooeyMaggots();
+                    creature.MoveToWorld(Map.GetSpawnPosition(Location, 2), Map);
+                    Effects.SendLocationParticles(EffectItem.Create(Location, Map, EffectItem.DefaultDuration), 0x3728, 8, 20, 5042);
+                }
+            }
+
+            Delete();
+        }
+
+        public StinkingCauldron(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadEncodedInt();
+
+            Timer.DelayCall(TimeSpan.FromSeconds(10), new TimerCallback(GooeyMaggotsSpawn));
+        }
+    }
+}

Scripts/Services/Revamped Dungeons/WrongDungeon/Items/WrongBarredMetalDoor.cs

@@ -0,0 +1,143 @@
+using Server.Network;
+using Server.Spells.Third;
+using System;
+
+namespace Server.Items
+{
+    public class WrongBarredMetalDoor : BaseDoor, ILockpickable, IMageUnlockable
+    {
+        private int m_LockLevel, m_MaxLockLevel, m_RequiredSkill;
+        private Mobile m_Picker;
+        private Timer m_Timer;
+        private bool m_MagicUnlocked;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Mobile Picker
+        {
+            get { return this.m_Picker; }
+            set { this.m_Picker = value; }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int MaxLockLevel
+        {
+            get { return this.m_MaxLockLevel; }
+            set { this.m_MaxLockLevel = value; }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int LockLevel
+        {
+            get { return this.m_LockLevel; }
+            set { this.m_LockLevel = value; }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int RequiredSkill
+        {
+            get { return this.m_RequiredSkill; }
+            set { this.m_RequiredSkill = value; }
+        }
+
+        [Constructable]
+        public WrongBarredMetalDoor(DoorFacing facing)
+            : base(0x685 + (2 * (int)facing), 0x686 + (2 * (int)facing), 0xEC, 0xF3, BaseDoor.GetOffset(facing))
+        {
+            this.Locked = true;
+            this.m_LockLevel = 80;
+            this.m_MaxLockLevel = 110;
+            this.m_RequiredSkill = 100;
+        }
+
+        public WrongBarredMetalDoor(Serial serial) : base(serial)
+        {
+        }
+
+        public virtual void LockPick(Mobile from)
+        {
+            this.Picker = from;
+            this.Locked = false;
+            this.m_Timer = new InternalTimer(this);
+            this.m_Timer.Start();
+        }
+
+        public override void OnTelekinesis(Mobile from)
+        {
+            this.m_Timer = new InternalTimer(this);
+            this.m_Timer.Start();
+
+            if (from.Skills.Magery.Value >= m_RequiredSkill)
+            {
+                m_MagicUnlocked = true;
+            }
+
+            Use(from);
+        }
+
+        public void OnMageUnlock(Mobile from)
+        {
+            this.m_Timer = new InternalTimer(this);
+            this.m_Timer.Start();
+
+            if (from.Skills.Magery.Value >= m_RequiredSkill)
+            {
+                m_MagicUnlocked = true;
+            }
+        }
+
+        public override void Use(Mobile from)
+        {
+            if (m_MagicUnlocked)
+            {
+                this.Locked = false;
+                m_MagicUnlocked = false;
+            }
+
+            if (this.Locked && !this.Open)                
+            {
+                from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 501746); // It appears to be locked.
+                return;
+            }
+
+            base.Use(from);
+        }
+
+        private class InternalTimer : Timer
+        {
+            private readonly BaseDoor m_Door;
+            public InternalTimer(BaseDoor door)
+                : base(TimeSpan.FromSeconds(10.0))
+            {
+                this.Priority = TimerPriority.OneSecond;
+                this.m_Door = door;
+            }
+
+            protected override void OnTick()
+            {
+                this.m_Door.Locked = true;
+            }
+        }
+
+        public override void Serialize(GenericWriter writer) // Default Serialize method
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+            
+            writer.Write((int)m_RequiredSkill);
+            writer.Write((int)m_MaxLockLevel);
+            writer.Write((int)m_LockLevel);
+        }
+
+        public override void Deserialize(GenericReader reader) // Default Deserialize method
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+            
+            m_RequiredSkill = reader.ReadInt();
+            m_MaxLockLevel = reader.ReadInt();
+            m_LockLevel = reader.ReadInt();
+
+            this.Locked = true;
+        }
+    }
+}

Scripts/Services/Revamped Dungeons/WrongDungeon/Items/WrongBedrolls.cs

@@ -0,0 +1,210 @@
+using System;
+
+namespace Server.Items
+{
+    public class WrongBedrollBase : Item
+    {
+        private Point3D m_PointDest;
+        private BedrollSpawner m_Spawner;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Point3D PointDest
+        {
+            get { return m_PointDest; }
+            set { m_PointDest = value; }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public BedrollSpawner BedrollSpawner
+        {
+            get { return m_Spawner; }
+            set { m_Spawner = value; }
+        }
+
+        [Constructable]
+        public WrongBedrollBase(int id)
+            : base(id)
+        {
+            this.Movable = false;
+        }
+
+        public WrongBedrollBase(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (!from.InRange(GetWorldLocation(), 2))
+            {
+                from.SendLocalizedMessage(500446); // That is too far away.
+                return;
+            }
+
+            from.RevealingAction();
+
+            if (this.PointDest != Point3D.Zero)
+            {
+                MysteriousTunnel mt = new MysteriousTunnel();
+                Effects.PlaySound(from.Location, from.Map, 0x3BD);
+
+                mt.PointDest = this.PointDest;
+                mt.MoveToWorld(Location, Map);
+                m_Spawner.MysteriousTunnels.Add(mt);
+            }
+            else
+            {
+                if (Utility.RandomDouble() < 0.5)
+                {
+                    Point3D loc = this.GetWorldLocation();
+                    Map facet = this.Map;
+
+                    this.SendMessageTo(from, 502999, 0x3B2); // You set off a trap!
+                    AOS.Damage(from, 40, 0, 100, 0, 0, 0);
+
+                    switch (Utility.Random(3))
+                    {
+                        case 0:
+                            {
+                                Effects.SendLocationEffect(loc, facet, 0x36BD, 15, 10);
+                                Effects.PlaySound(loc, facet, 0x307);
+                                break;
+                            }
+                        case 1:
+                            {
+                                Effects.PlaySound(loc, this.Map, 0x307);
+                                Effects.SendLocationEffect(new Point3D(loc.X - 1, loc.Y, loc.Z), this.Map, 0x36BD, 15);
+                                Effects.SendLocationEffect(new Point3D(loc.X + 1, loc.Y, loc.Z), this.Map, 0x36BD, 15);
+                                Effects.SendLocationEffect(new Point3D(loc.X, loc.Y - 1, loc.Z), this.Map, 0x36BD, 15);
+                                Effects.SendLocationEffect(new Point3D(loc.X, loc.Y + 1, loc.Z), this.Map, 0x36BD, 15);
+                                Effects.SendLocationEffect(new Point3D(loc.X + 1, loc.Y + 1, loc.Z + 11), this.Map, 0x36BD, 15);
+                                break;
+                            }
+                        case 2:
+                            {
+                                Effects.SendLocationEffect(loc, facet, 0x113A, 10, 20);
+                                Effects.PlaySound(loc, facet, 0x231);
+                                break;
+                            }
+                    }
+                }
+                else
+                {
+                    if (Utility.RandomDouble() < 0.01)
+                    {
+                        Item soap = new Soap();
+
+                        Effects.PlaySound(from.Location, from.Map, 0x247);  //powder
+
+                        if (Utility.RandomBool())
+                        {
+                            from.AddToBackpack(soap);
+                            from.SendLocalizedMessage(1152268, String.Format("soap"));
+                        }
+                        else
+                        {
+                            soap.MoveToWorld(this.Location, this.Map);
+                        }
+                    }
+                    else
+                    {
+                        Effects.PlaySound(from.Location, from.Map, 0x3E3);  //leather
+                        from.SendLocalizedMessage(1152212); //You tear the bedroll to pieces but find nothing.
+                    }
+                }
+            }
+
+            this.Delete();
+        }
+
+        private void SendMessageTo(Mobile to, int number, int hue)
+        {
+            if (this.Deleted || !to.CanSee(this))
+                return;
+
+            to.Send(new Network.MessageLocalized(this.Serial, this.ItemID, Network.MessageType.Regular, hue, 3, number, "", ""));
+        }
+
+        private void SendMessageTo(Mobile to, string text, int hue)
+        {
+            if (this.Deleted || !to.CanSee(this))
+                return;
+
+            to.Send(new Network.UnicodeMessage(this.Serial, this.ItemID, Network.MessageType.Regular, hue, 3, "ENU", "", text));
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+
+            writer.Write(this.m_Spawner);
+            writer.Write(this.m_PointDest);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            this.m_Spawner = (BedrollSpawner)reader.ReadItem();
+            this.m_PointDest = reader.ReadPoint3D();
+        }
+    }
+
+    public class WrongBedrollSouth : WrongBedrollBase
+    {
+        public override int LabelNumber { get { return 1022645; } } // bedroll
+
+        [Constructable]
+        public WrongBedrollSouth()
+            : base(0x0A56)
+        {
+        }
+
+        public WrongBedrollSouth(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();
+        }
+    }
+
+    public class WrongBedrollEast : WrongBedrollBase
+    {
+        public override int LabelNumber { get { return 1022645; } } // bedroll
+
+        [Constructable]
+        public WrongBedrollEast()
+            : base(0xA55)
+        {
+        }
+
+        public WrongBedrollEast(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/Services/Revamped Dungeons/WrongDungeon/Items/WrongMazeWall.cs

@@ -0,0 +1,62 @@
+using System;
+using Server.Network;
+
+namespace Server.Items
+{
+    public class WrongMazeWall : BaseWall
+    {
+        [Constructable]
+        public WrongMazeWall()
+            : base(578)
+        {
+            Movable = false;
+            Visible = false;
+        }
+
+        public override void OnSingleClick(Mobile from)
+        {
+            if (this.Name != null)
+                from.Send(new AsciiMessage(Serial, ItemID, MessageType.Label, 0, 3, "", this.Name));
+            else
+                from.Send(new AsciiMessage(Serial, ItemID, MessageType.Label, 0, 3, "", "a dungeon wall"));
+        }
+
+        public override bool HandlesOnMovement { get { return true; } }
+
+        public override void OnMovement(Mobile m, Point3D oldLocation)
+        {
+            IPooledEnumerable eable = GetMobilesInRange(2);
+
+            foreach (object o in eable)
+            {
+                if (o is Mobile && ((Mobile)o).InRange(Location, 1))
+                {
+                    eable.Free();
+                    Visible = true;
+                    return;
+                }
+            }
+            eable.Free();
+            Visible = false;
+        }
+
+        public WrongMazeWall(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/Services/Revamped Dungeons/WrongDungeon/Mobile/Archmage.cs

@@ -0,0 +1,92 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles 
+{ 
+    [CorpseName("an archmage corpse")] 
+    public class Archmage : BaseCreature 
+    { 
+        [Constructable] 
+        public Archmage()
+            : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = NameList.RandomName("evil mage");
+            this.Title = "The Insane The Archmage";
+            this.Body = Utility.RandomList(125, 126);
+
+            PackItem(new Robe(Utility.RandomMetalHue()));
+
+            SetStr(85, 90);
+            SetDex(194, 203);
+            SetInt(237, 241);
+
+            SetHits(3106, 3122);
+            SetMana(578, 616);
+
+            SetDamage(15, 20);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 65, 68);
+            SetResistance(ResistanceType.Fire, 65, 66);
+            SetResistance(ResistanceType.Cold, 62, 69);
+            SetResistance(ResistanceType.Poison, 62, 67);
+            SetResistance(ResistanceType.Energy, 64, 68);
+
+            SetSkill(SkillName.EvalInt, 88.9, 94.1);
+            SetSkill(SkillName.Magery, 96.9, 98.4);
+            SetSkill(SkillName.Meditation, 89.9, 90.7);
+            SetSkill(SkillName.MagicResist, 87.2, 88.7);
+            SetSkill(SkillName.Tactics, 78.2, 79.9);
+            SetSkill(SkillName.Wrestling, 84.8, 92.6);
+
+            Fame = 14500;
+            Karma = -14500;
+
+            VirtualArmor = 16;
+			switch (Utility.Random(16))
+            {
+                case 0: PackItem(new BloodOathScroll()); break;
+                case 1: PackItem(new CurseWeaponScroll()); break;
+                case 2: PackItem(new StrangleScroll()); break;
+                case 3: PackItem(new LichFormScroll()); break;
+			}
+            PackReg(23);
+            PackItem(new Sandals());
+
+            if (Utility.RandomDouble() < 0.75)
+            {
+                PackItem(new SeveredHumanEars());
+            }
+        }
+
+        public Archmage(Serial serial)
+            : base(serial)
+        { 
+        }
+
+        public override bool CanRummageCorpses { get { return true; } }
+        public override bool AlwaysMurderer { get { return true; } }
+        public override int Meat { get { return 1; } }
+        public override int TreasureMapLevel { get { return Core.AOS ? 2 : 0; } }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Average);
+            AddLoot(LootPack.Meager);
+            AddLoot(LootPack.MedScrolls, 2);
+        }
+
+        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/Services/Revamped Dungeons/WrongDungeon/Mobile/BrigandCannibal.cs

@@ -0,0 +1,66 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles 
+{ 
+    [CorpseName("Brigand Cannibal corpse")] 
+    public class BrigandCannibal : Brigand
+    { 
+        [Constructable] 
+        public BrigandCannibal()
+            : base()
+        {
+            Title = "the brigand cannibal";
+            Hue = 33782;
+
+            SetStr(68, 95);
+            SetDex(81, 95);
+            SetInt(110, 115);
+
+            SetHits(2058, 2126);
+            SetMana(552, 553);
+
+            SetDamage(10, 23);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 65, 68);
+            SetResistance(ResistanceType.Fire, 65, 66);
+            SetResistance(ResistanceType.Cold, 62, 69);
+            SetResistance(ResistanceType.Poison, 62, 67);
+            SetResistance(ResistanceType.Energy, 64, 68);
+
+            SetSkill(SkillName.MagicResist, 96.9, 96.9);
+            SetSkill(SkillName.Tactics, 94.0, 94.0);
+            SetSkill(SkillName.Swords, 54.3, 54.3);
+
+            Fame = 14500;
+            Karma = -14500;
+
+            VirtualArmor = 16;
+        }
+
+        public BrigandCannibal(Serial serial)
+            : base(serial)
+        { 
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Average);
+            AddLoot(LootPack.Meager);
+        }
+
+        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/Services/Revamped Dungeons/WrongDungeon/Mobile/BrigandCannibalMage.cs

@@ -0,0 +1,67 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles 
+{ 
+    [CorpseName("an archmage corpse")] 
+    public class BrigandCannibalMage : EvilMage
+    { 
+        [Constructable] 
+        public BrigandCannibalMage()
+            : base()
+        {
+            Title = "the brigand cannibal mage";
+
+            SetStr(68, 95);
+            SetDex(81, 95);
+            SetInt(110, 115);
+
+            SetHits(2058, 2126);
+            SetMana(552, 553);
+
+            SetDamage(10, 23);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 50, 60);
+            SetResistance(ResistanceType.Fire, 50, 60);
+            SetResistance(ResistanceType.Cold, 50, 60);
+            SetResistance(ResistanceType.Poison, 50, 60);
+            SetResistance(ResistanceType.Energy, 50, 60);
+
+            SetSkill(SkillName.MagicResist, 96.9, 96.9);
+            SetSkill(SkillName.Tactics, 94.0, 94.0);
+            SetSkill(SkillName.Wrestling, 54.3, 54.3);
+            SetSkill(SkillName.Necromancy, 94.0, 94.0);
+            SetSkill(SkillName.SpiritSpeak, 54.3, 54.3);
+
+            Fame = 14500;
+            Karma = -14500;
+            
+            if (Utility.RandomDouble() < 0.75)
+            {
+                PackItem(new SeveredHumanEars());
+            }
+
+            AI = AIType.AI_NecroMage;
+            SetSpecialAbility(SpecialAbility.LifeLeech);
+        }
+
+        public BrigandCannibalMage(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/Services/Revamped Dungeons/WrongDungeon/Mobile/CaveTrollWrong.cs

@@ -0,0 +1,86 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Cave Troll corpse")]
+    public class CaveTrollWrong : BaseCreature
+    {
+        [Constructable]
+        public CaveTrollWrong()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            Name = "a Cave Troll";
+            Body = Utility.RandomList(53, 54);
+            BaseSoundID = 461;
+            this.Hue = 674;
+
+            SetStr(118, 118);
+            SetDex(58, 58);
+            SetInt(65, 65);
+
+            SetHits(2136, 2136);
+
+            SetDamage(8, 14);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 76, 76);
+            SetResistance(ResistanceType.Fire, 55, 55);
+            SetResistance(ResistanceType.Cold, 72, 72);
+            SetResistance(ResistanceType.Poison, 75, 75);
+            SetResistance(ResistanceType.Energy, 50, 50);
+
+            SetSkill(SkillName.MagicResist, 87.4, 87.4);
+            SetSkill(SkillName.Tactics, 125.8, 125.8);
+            SetSkill(SkillName.Wrestling, 137.5, 137.5);
+
+            Fame = 3500;
+            Karma = -3500;
+
+            VirtualArmor = 40;
+        }
+
+        public CaveTrollWrong(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool CanRummageCorpses
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int TreasureMapLevel
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override int Meat
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Average);
+        }
+
+        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/Services/Revamped Dungeons/WrongDungeon/Mobile/DemonicJailor.cs

@@ -0,0 +1,182 @@
+using System;
+using Server;
+using Server.Items;
+using System.Collections;
+using Server.Network;
+
+namespace Server.Mobiles 
+{ 
+    public class DemonicJailor : BaseCreature 
+    { 
+        [Constructable] 
+        public DemonicJailor()
+            : base(AIType.AI_Melee, FightMode.Closest, 15, 1, 0.1, 0.3)
+        {
+            this.Name = NameList.RandomName("male");
+            this.SpeechHue = Utility.RandomDyedHue(); 
+            this.Title = "the demonic jailor";
+            this.Hue = 34531;
+            this.Body = 0x190;             
+
+            this.SetStr(386, 400);
+            this.SetDex(151, 165);
+            this.SetInt(161, 175);
+
+            this.SetDamage(8, 10);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 35, 45);
+            this.SetResistance(ResistanceType.Fire, 25, 30);
+            this.SetResistance(ResistanceType.Cold, 25, 30);
+            this.SetResistance(ResistanceType.Poison, 10, 20);
+            this.SetResistance(ResistanceType.Energy, 10, 20);
+
+            this.SetSkill(SkillName.Anatomy, 125.0);
+            this.SetSkill(SkillName.Fencing, 46.0, 77.5);
+            this.SetSkill(SkillName.Macing, 35.0, 57.5);
+            this.SetSkill(SkillName.Poisoning, 60.0, 82.5);
+            this.SetSkill(SkillName.DetectHidden, 100);
+            this.SetSkill(SkillName.MagicResist, 83.5, 92.5);
+            this.SetSkill(SkillName.Swords, 125.0);
+            this.SetSkill(SkillName.Tactics, 125.0);
+            this.SetSkill(SkillName.Lumberjacking, 125.0);
+
+            this.Fame = 5000;
+            this.Karma = -5000;
+
+            this.VirtualArmor = 40;
+
+            this.SetWearable(new ShortPants(Utility.RandomRedHue()));
+            this.AddItem(new Sandals(Utility.RandomRedHue())); 
+            this.AddItem(new Shirt(Utility.RandomRedHue()));
+            this.AddItem(new SkinningKnife());
+
+            Utility.AssignRandomHair(this);
+        }
+
+        public override void OnGaveMeleeAttack(Mobile defender)
+        {
+            base.OnGaveMeleeAttack(defender);
+        
+            Point3D loc = new Point3D(5703, 639, 0);
+            Map map = this.Map;
+
+            Effects.SendLocationParticles(EffectItem.Create(loc, map, EffectItem.DefaultDuration), 0x3728, 10, 10, 0, 0, 2023, 0);
+            Effects.PlaySound(loc, map, 0x1FE);
+
+            BaseCreature.TeleportPets(defender, loc, map);
+
+            defender.MoveToWorld(loc, map);
+
+            defender.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1152076); // You are captured by the jailor and returned to your cell.
+        }
+
+        public override void OnDamagedBySpell(Mobile caster)
+        {
+            ParalyzeAttack(caster);
+        }
+
+        private static Hashtable m_Table;
+
+        public virtual void ParalyzeAttack(Mobile to)
+        {
+            if (m_Table == null)
+                m_Table = new Hashtable();
+
+            if (to.Alive && to.Player && m_Table[to] == null)
+            {
+                to.SendSpeedControl(SpeedControlType.WalkSpeed);
+                to.FixedEffect(0x376A, 6, 1);
+                to.SendLocalizedMessage(500111); // You are frozen and cannot move.
+                to.PlaySound(0x204);
+
+                m_Table[to] = Timer.DelayCall(TimeSpan.FromSeconds(15), new TimerStateCallback(EndParalyze_Callback), to);
+            }
+        }
+
+        private void EndParalyze_Callback(object state)
+        {
+            if (state is Mobile)
+                ParalyzeEnd((Mobile)state);
+        }
+
+        public virtual void ParalyzeEnd(Mobile from)
+        {
+            if (m_Table == null)
+                m_Table = new Hashtable();
+
+            m_Table[from] = null;
+
+            from.SendSpeedControl(SpeedControlType.Disable);
+        }
+
+        public static bool UnderParalyzeAttack(Mobile from)
+        {
+            if (m_Table == null)
+                m_Table = new Hashtable();
+
+            return m_Table[from] != null;
+        }
+
+        public DemonicJailor(Serial serial)
+            : base(serial)
+        { 
+        }
+
+        private DateTime m_NextTerror;
+
+        public override void OnMovement(Mobile m, Point3D oldLocation)
+        {
+
+            if (this.UseSkill(SkillName.DetectHidden))
+                m.RevealingAction();
+            base.OnMovement(m, oldLocation);
+
+               if (m_NextTerror < DateTime.Now && m != null && InRange(m.Location, 3) && m.AccessLevel == AccessLevel.Player)
+            {
+                m.Frozen = true;
+                m.SendLocalizedMessage(1080342, Title, 33); // Terror slices into your very being, destroying any chance of resisting ~1_name~ you might have had
+
+                Timer.DelayCall(TimeSpan.FromSeconds(5), new TimerStateCallback(Terrorize), m);
+            }
+        }
+
+        private void Terrorize(object o)
+        {
+            if (o is Mobile)
+            {
+                Mobile m = (Mobile)o;
+
+                m.Frozen = false;
+                m.SendLocalizedMessage(1005603); // You can move again!
+
+                m_NextTerror = DateTime.Now + TimeSpan.FromMinutes(1);
+            }
+        }
+
+        public override bool AlwaysMurderer { get { return true; } }
+        public override bool BardImmune { get { return !Core.SE; } }
+        public override bool Unprovokable { get { return Core.SE; } }
+        public override bool AreaPeaceImmune { get { return Core.SE; } }
+        public override Poison PoisonImmune { get { return Poison.Lethal; } }
+
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.FilthyRich);
+            this.AddLoot(LootPack.Meager);
+        }       
+
+        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/Services/Revamped Dungeons/WrongDungeon/Mobile/Fezzik.cs

@@ -0,0 +1,111 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("an ogre corpse")]
+    public class Fezzik : BaseCreature
+    {
+        private DateTime m_StinkingCauldronTime;
+
+        [Constructable]
+        public Fezzik()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "Fezzik";
+            this.Title = "The Ogre Cook";
+            this.Body = 1;
+            this.BaseSoundID = 427;
+
+            this.SetStr(1142, 1381);
+            this.SetDex(73, 90);
+            this.SetInt(52, 84);
+            
+            this.SetMana(0);
+
+            this.SetDamage(25, 30);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 75, 80);
+            this.SetResistance(ResistanceType.Fire, 70, 75);
+            this.SetResistance(ResistanceType.Cold, 65, 75);
+            this.SetResistance(ResistanceType.Poison, 55, 65);
+            this.SetResistance(ResistanceType.Energy, 65, 75);
+
+            this.SetSkill(SkillName.MagicResist, 133.3, 151.9);
+            this.SetSkill(SkillName.Tactics, 120.3, 130.0);
+            this.SetSkill(SkillName.Wrestling, 122.2, 128.9);
+            this.SetSkill(SkillName.Anatomy, 10.0, 15.0);
+            this.SetSkill(SkillName.DetectHidden, 90.0);
+            this.SetSkill(SkillName.Parry, 95.0, 100.0);
+
+            this.Fame = 3000;
+            this.Karma = -3000;
+
+            this.VirtualArmor = 52;
+
+            this.PackItem(new Club());
+        }
+
+        public Fezzik(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int Meat { get { return 2; } }
+
+        public override void AlterDamageScalarFrom(Mobile caster, ref double scalar)
+        {
+            if (0.5 >= Utility.RandomDouble())
+                this.SpawnGreenGoo();
+        }
+
+        public override void OnGotMeleeAttack(Mobile attacker)
+        {
+            base.OnGotMeleeAttack(attacker);
+
+            if (0.5 >= Utility.RandomDouble())
+                this.SpawnGreenGoo();
+        }
+
+        public void SpawnGreenGoo()
+        {
+            if (this.m_StinkingCauldronTime <= DateTime.UtcNow)
+            {
+                new StinkingCauldron().MoveToWorld(this.Location, this.Map);
+
+                this.m_StinkingCauldronTime = DateTime.UtcNow + TimeSpan.FromMinutes(2);
+            }
+        }
+
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);
+
+            if (0.1 > Utility.RandomDouble())
+            {
+                c.DropItem(new RecipeScroll(603));
+            } 
+        }
+		
+		public override int TreasureMapLevel { get { return 3; } }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Meager, 2);
+        }
+
+        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/Services/Revamped Dungeons/WrongDungeon/Mobile/GooeyMaggots.cs

@@ -0,0 +1,176 @@
+using Server.Network;
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a gooey maggots corpse")]
+    public class GooeyMaggots : BaseCreature
+    {
+        [Constructable]
+        public GooeyMaggots()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "Gooey Maggots";
+            this.Body = 319;
+            this.BaseSoundID = 898;
+
+            this.SetStr(738, 763);
+            this.SetDex(61, 70);
+            this.SetInt(10);
+
+            this.SetMana(0);
+
+            this.SetDamage(3, 9);
+
+            this.SetDamageType(ResistanceType.Physical, 50);
+            this.SetDamageType(ResistanceType.Poison, 50);
+
+            this.SetResistance(ResistanceType.Physical, 60, 70);
+            this.SetResistance(ResistanceType.Fire, 60, 70);
+            this.SetResistance(ResistanceType.Cold, 50, 60);
+            this.SetResistance(ResistanceType.Poison, 60, 70);
+            this.SetResistance(ResistanceType.Energy, 60, 70);
+
+            this.SetSkill(SkillName.Tactics, 80.2, 89.7);
+            this.SetSkill(SkillName.Wrestling, 80.2, 87.5);
+
+            this.Fame = 1000;
+            this.Karma = -1000;
+
+            this.VirtualArmor = 24;
+
+            Timer selfDeleteTimer = new InternalSelfDeleteTimer(this);
+            selfDeleteTimer.Start();
+        }
+
+        public GooeyMaggots(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Meager, 2);
+        }
+
+        protected override void OnLocationChange(Point3D oldLocation)
+        {
+            new GooeyMaggotSlime().MoveToWorld(oldLocation, this.Map);
+
+            base.OnLocationChange(oldLocation);
+        }
+
+        public class InternalSelfDeleteTimer : Timer
+        {
+            private GooeyMaggots creature;
+
+            public InternalSelfDeleteTimer(Mobile p) : base(TimeSpan.FromMinutes(3))
+            {
+                Priority = TimerPriority.FiveSeconds;
+                creature = ((GooeyMaggots)p);
+            }
+            protected override void OnTick()
+            {
+                if (creature.Map != Map.Internal)
+                {
+                    creature.Delete();
+                    this.Stop();
+                }
+            }
+        }
+
+        public override Poison PoisonImmune { get { return Poison.Lethal; } }
+
+        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();
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+        }
+    }
+
+    public class GooeyMaggotSlime : Item
+    {
+        public override int LabelNumber { get { return 1015246; } } // Slime
+
+        [Constructable]
+        public GooeyMaggotSlime()
+            : this(Utility.RandomList(0x1645, 0x122A, 0x122B, 0x122C, 0x122D, 0x122E, 0x122F))
+        {
+        }
+
+        [Constructable]
+        public GooeyMaggotSlime(int itemID)
+            : base(itemID)
+        {
+            this.Movable = false;
+            this.Hue = 363;
+
+            new InternalTimer(this).Start();
+        }
+
+        public override bool OnMoveOver(Mobile from)
+        {
+            if (!from.IsStaff() && from.Alive && from.Player)
+            {
+                from.SendSpeedControl(SpeedControlType.WalkSpeed);
+                from.SendLocalizedMessage(1152144); // You suddenly find yourself unable to run.
+
+                Timer.DelayCall(TimeSpan.FromSeconds(1), new TimerCallback(
+                    delegate
+                    {
+                        from.SendSpeedControl(SpeedControlType.Disable);
+                        from.SendLocalizedMessage(1152145); // You are are free to move again.
+                    }));
+
+                this.Delete();
+            }
+
+            return base.OnMoveOver(from);
+        }
+
+        public GooeyMaggotSlime(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();
+
+            new InternalTimer(this).Start();
+        }
+
+        private class InternalTimer : Timer
+        {
+            private readonly Item m_Slime;
+            public InternalTimer(Item slime)
+                : base(TimeSpan.FromSeconds(10.0))
+            {
+                this.Priority = TimerPriority.OneSecond;
+
+                this.m_Slime = slime;
+            }
+
+            protected override void OnTick()
+            {
+                this.m_Slime.Delete();
+            }
+        }
+    }
+}

Scripts/Services/Revamped Dungeons/WrongDungeon/Mobile/HungryOgre.cs

@@ -0,0 +1,73 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a hungry ogre corpse")]
+    public class HungryOgre : BaseCreature
+    {
+        [Constructable]
+        public HungryOgre()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "Hungry Ogre";
+            this.Body = 0x1;
+            this.BaseSoundID = 427;
+
+            this.SetStr(188, 223);
+            this.SetDex(62, 79);
+            this.SetInt(49, 59);
+
+            this.SetHits(1107, 1205);
+            this.SetMana(49, 59);
+
+            this.SetDamage(15, 20);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 50, 60);
+            this.SetResistance(ResistanceType.Fire, 70, 80);
+            this.SetResistance(ResistanceType.Cold, 50, 60);
+            this.SetResistance(ResistanceType.Poison, 70, 80);
+            this.SetResistance(ResistanceType.Energy, 60, 70);
+
+            this.SetSkill(SkillName.MagicResist, 61.1, 69.9);
+            this.SetSkill(SkillName.Tactics, 102.3, 109.6);
+            this.SetSkill(SkillName.Wrestling, 100.9, 108.7);
+
+            this.Fame = 12000;
+            this.Karma = -12000;
+
+            this.VirtualArmor = 32;
+
+            this.PackItem(new Club());
+        }
+
+        public HungryOgre(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool CanRummageCorpses { get { return true; } }
+        public override int TreasureMapLevel { get { return 1; } }
+        public override int Meat { get { return 2; } }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Average);
+            AddLoot(LootPack.Potions);
+        }
+
+        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/Services/Revamped Dungeons/WrongDungeon/Mobile/LizardmanDefender.cs

@@ -0,0 +1,73 @@
+using System;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a lizardman corpse")]
+    public class LizardmanDefender : BaseCreature
+    {
+        [Constructable]
+        public LizardmanDefender()
+            : base(AIType.AI_Archer, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = NameList.RandomName("lizardman");
+            this.Title = "the defender";
+            this.Body = Utility.RandomList(35, 36);
+            this.BaseSoundID = 417;
+            this.Hue = 1949;
+
+            SetStr(157, 180);
+            SetDex(105, 108);
+            SetInt(50, 57);
+
+            SetHits(1100, 1157);
+
+            SetDamage(10, 15);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 50, 60);
+            SetResistance(ResistanceType.Fire, 50, 60);
+            SetResistance(ResistanceType.Cold, 50, 60);
+            SetResistance(ResistanceType.Poison, 50, 60);
+
+            SetSkill(SkillName.MagicResist, 65.1, 90.0);
+            SetSkill(SkillName.Tactics, 95.1, 120.0);
+            SetSkill(SkillName.Wrestling, 95.1, 120.0);
+
+            Fame = 11000;
+            Karma = -11000;
+
+            VirtualArmor = 28;
+        }
+
+        public LizardmanDefender(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override InhumanSpeech SpeechType { get { return InhumanSpeech.Lizardman; } }
+        public override bool CanRummageCorpses { get { return true; } }
+		public override int TreasureMapLevel { get { return 3; } }
+        public override int Meat { get { return 1; } }
+        public override int Hides { get { return 12; } }
+        public override HideType HideType { get { return HideType.Spined; } }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Meager);
+        }
+
+        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/Services/Revamped Dungeons/WrongDungeon/Mobile/LizardmanSquatter.cs

@@ -0,0 +1,107 @@
+using System;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a lizardman squatter corpse")]
+    public class LizardmanSquatter : BaseCreature
+    {
+        [Constructable]
+        public LizardmanSquatter()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = NameList.RandomName("lizardman");
+            this.Title = "the squatter";
+            Body = Utility.RandomList(35, 36);
+            BaseSoundID = 417;
+
+            SetStr(105, 138);
+            SetDex(89, 114);
+            SetInt(50, 66);
+
+            SetHits(787, 869);
+
+            SetDamage(10, 15);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 60, 70);
+            SetResistance(ResistanceType.Fire, 50, 60);
+            SetResistance(ResistanceType.Cold, 50, 60);
+            SetResistance(ResistanceType.Poison, 50, 60);
+
+            SetSkill(SkillName.MagicResist, 35.1, 90.0);
+            SetSkill(SkillName.Tactics, 95.1, 120.0);
+            SetSkill(SkillName.Wrestling, 95.1, 120.0);
+
+            Fame = 10000;
+            Karma = -10000;
+
+            VirtualArmor = 28;
+        }
+
+        public LizardmanSquatter(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override InhumanSpeech SpeechType
+        {
+            get
+            {
+                return InhumanSpeech.Lizardman;
+            }
+        }
+        public override bool CanRummageCorpses
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int Meat
+        {
+            get
+            {
+                return 1;
+            }
+        }
+        public override int Hides
+        {
+            get
+            {
+                return 12;
+            }
+        }
+		public override int TreasureMapLevel
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override HideType HideType
+        {
+            get
+            {
+                return HideType.Spined;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Meager);
+        }
+
+        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/Services/Revamped Dungeons/WrongDungeon/Mobile/PrisonRat.cs

@@ -0,0 +1,70 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a rat corpse")]
+    public class PrisonRat : BaseCreature
+    {
+        [Constructable]
+        public PrisonRat()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "a prison rat";
+            this.Body = 0xEE;
+            this.Hue = 443;
+            this.BaseSoundID = 0xCC;
+
+            this.SetStr(9);
+            this.SetDex(35);
+            this.SetInt(7, 10);
+
+            this.SetHits(50);
+            this.SetStam(25);
+            this.SetMana(7, 10);
+
+            this.SetDamage(5, 8);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 5, 10);
+            this.SetResistance(ResistanceType.Poison, 15, 25);
+            this.SetResistance(ResistanceType.Energy, 5, 10);
+
+            this.SetSkill(SkillName.MagicResist, 3.7, 20.7);
+            this.SetSkill(SkillName.Tactics, 6.7, 17.0);
+            this.SetSkill(SkillName.Wrestling, 9.1, 19.5);
+
+            this.Fame = 150;
+            this.Karma = -150;
+
+            this.VirtualArmor = 6;
+        }
+
+        public PrisonRat(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int Meat { get { return 1; } }
+        public override FoodType FavoriteFood { get { return FoodType.Fish; } }
+
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.Poor);
+        }
+
+        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/Services/Revamped Dungeons/WrongDungeon/Mobile/SavagePackWolf.cs

@@ -0,0 +1,68 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a wolf corpse")]
+    [TypeAlias("Server.Mobiles.SavagePackwolf")]
+    public class SavagePackWolf : BaseCreature
+    {
+        [Constructable]
+        public SavagePackWolf()
+            : base(AIType.AI_Melee, FightMode.Weakest, 10, 1, 0.2, 0.4)
+        {
+            Name = "a savage pack wolf";
+            Body = 0xE1;
+            BaseSoundID = 0xE5;
+
+            SetStr(100, 116);
+            SetDex(51, 61);
+            SetInt(11, 21);
+
+            SetHits(650, 671);
+            SetMana(0);
+
+            SetDamage(9, 12);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 50, 60);
+            SetResistance(ResistanceType.Fire, 50, 60);
+            SetResistance(ResistanceType.Cold, 60, 70);
+            SetResistance(ResistanceType.Poison, 50, 60);
+            SetResistance(ResistanceType.Energy, 50, 60);
+
+            SetSkill(SkillName.MagicResist, 60.7, 74.0);
+            SetSkill(SkillName.Tactics, 80.9, 94.4);
+            SetSkill(SkillName.Wrestling, 89.0, 97.1);
+
+            Fame = 450;
+            Karma = -450;
+
+            VirtualArmor = 26;
+            Tamable = false;
+        }
+
+        public SavagePackWolf(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool AlwaysMurderer { get { return true; } }
+        public override int Meat { get { return 1; } }
+        public override int Hides { get { return 5; } }
+        public override FoodType FavoriteFood { get { return FoodType.Meat; } }
+        public override PackInstinct PackInstinct { get { return PackInstinct.Canine; } }
+
+        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/Services/Revamped Dungeons/WrongDungeon/Mobile/WrongPrisoner.cs

@@ -0,0 +1,59 @@
+using System;
+using Server.Items;
+
+namespace Server.Engines.Quests
+{
+    public class WrongPrisoner : BaseEscort
+    {
+        [Constructable]
+        public WrongPrisoner()
+            : base()
+        {
+            this.Title = "the prisoner";
+            this.IsPrisoner = true;
+            this.Female = false;
+            this.Body = 0x190;
+            this.Hue = 33802;
+            this.Name = NameList.RandomName("male");
+
+            this.SetWearable(new PlateChest());
+            this.SetWearable(new PlateArms());
+            this.SetWearable(new PlateGloves());
+            this.SetWearable(new PlateLegs());
+        }
+
+        public WrongPrisoner(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void InitOutfit() { }
+
+        public override bool IsInvulnerable { get { return !this.Controlled; } }
+
+        public override Type[] Quests
+        {
+            get
+            {
+                return new Type[] 
+                {
+                    typeof(EscortToWrongEntrance)
+                };
+            }
+        }
+
+        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/Services/Revamped Dungeons/WrongDungeon/Quests/EscortToWrongEntrance.cs

@@ -0,0 +1,75 @@
+using System;
+using Server.Items;
+
+namespace Server.Engines.Quests
+{
+    public class EscortToWrongEntrance : BaseQuest
+    {
+        public EscortToWrongEntrance()
+            : base()
+        {
+            this.AddObjective(new EscortObjective("Wrong Entrance"));
+            
+            this.AddReward(new BaseReward("Compassion"));
+            this.AddReward(new BaseReward(typeof(Gold), 500, 1062577));
+        }
+
+        /*We Who Are About To Die*/
+        public override object Title
+        {
+            get
+            {
+                return 1152096;
+            }
+        }
+        /*Take the prisoner to the entrance of Wrong Dungeon so they can escape.  The brigands will try to kill them,
+         * so you must defend them.<br><center>-----</center><br>I don't know what to do, they took my weapons and 
+         * broke my hands.  They follow these two necromancers and I think they intend to eat us as part of some 
+         * dark ritual!  Will you help me?  Please?  Get me out of this prison, please....*/
+        public override object Description
+        {
+            get
+            {
+                return 1152097;
+            }
+        }
+        /*I am surely doomed....*/
+        public override object Refuse
+        {
+            get
+            {
+                return 1152099;
+            }
+        }
+        /*I couldn't see when they brought me here, how much farther to the entrance of this horrid place?*/
+        public override object Uncomplete
+        {
+            get
+            {
+                return 1152100;
+            }
+        }/*I am indebted to you, friend.  Please, take this as a token of my thanks.  I'm sorry it is all 
+          * I have, they took everything else from me.*/
+        public override object Complete
+        {
+            get
+            {
+                return 1152101;
+            }
+        }
+
+        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/Services/Revamped Dungeons/WrongDungeon/Region.cs

@@ -0,0 +1,64 @@
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Regions;
+using System.Xml;
+using Server.Network;
+using System;
+
+namespace Server.Engines.Blackthorn
+{
+	public class WrongLevel3 : DungeonRegion
+	{
+        private List<Mobile> DeathList = new List<Mobile>();
+
+        public WrongLevel3(XmlElement xml, Map map, Region parent)
+            : base(xml, map, parent)
+        {
+        }
+
+        public override void OnDeath(Mobile m)
+        {
+            if (m is PlayerMobile)
+            {
+                m.MoveToWorld(new Point3D(5703, 639, 0), this.Map);                      
+
+                if (!DeathList.Contains(m))
+                {
+                    m.Resurrect();
+                    DeathList.Add(m);
+                }
+                else
+                {
+                    DeathList.Remove(m);
+                }
+
+                Timer.DelayCall(TimeSpan.FromSeconds(2), () => m.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1152076)); // You are captured by the jailor and returned to your cell.                       
+            }
+        }
+
+        public override void OnExit(Mobile m)
+        {
+            if (m is PlayerMobile)
+            {
+                if (DeathList.Contains(m))
+                    DeathList.Remove(m);
+            }
+
+            base.OnExit(m);
+        }
+    }
+
+    public class WrongJail : DungeonRegion
+    {
+        public WrongJail(XmlElement xml, Map map, Region parent)
+            : base(xml, map, parent)
+        {
+        }
+
+        public override bool AllowHarmful(Mobile from, IDamageable target)
+        {
+            return false;
+        }
+    }
+}