Overwrite

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

Scripts/Services/Doom/GauntletSpawner.cs

@@ -0,0 +1,964 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Server.Commands;
+using Server.Items;
+using Server.Mobiles;
+using Server.Regions;
+
+namespace Server.Engines.Doom
+{
+    public enum GauntletSpawnerState
+    {
+        InSequence,
+        InProgress,
+        Completed
+    }
+
+    public class GauntletSpawner : Item
+    {
+        public const int PlayersPerSpawn = 5;
+        public const int InSequenceItemHue = 0x000;
+        public const int InProgressItemHue = 0x676;
+        public const int CompletedItemHue = 0x455;
+
+        private GauntletSpawnerState m_State;
+
+        private string m_TypeName;
+
+        private BaseDoor m_Door;
+        private BaseAddon m_Addon;
+
+        private GauntletSpawner m_Sequence;
+
+        private List<Mobile> m_Creatures;
+        private List<BaseTrap> m_Traps;
+
+        private Rectangle2D m_RegionBounds;
+
+        private Region m_Region;
+        private Timer m_Timer;
+
+        [Constructable]
+        public GauntletSpawner()
+            : this(null)
+        {
+        }
+
+        [Constructable]
+        public GauntletSpawner(string typeName)
+            : base(0x36FE)
+        {
+            Visible = false;
+            Movable = false;
+
+            m_TypeName = typeName;
+            m_Creatures = new List<Mobile>();
+            m_Traps = new List<BaseTrap>();
+        }
+
+        public GauntletSpawner(Serial serial)
+            : base(serial)
+        {
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public string TypeName
+        {
+            get
+            {
+                return m_TypeName;
+            }
+            set
+            {
+                m_TypeName = value;
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public BaseDoor Door
+        {
+            get
+            {
+                return m_Door;
+            }
+            set
+            {
+                m_Door = value;
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public BaseAddon Addon
+        {
+            get
+            {
+                return m_Addon;
+            }
+            set
+            {
+                m_Addon = value;
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public GauntletSpawner Sequence
+        {
+            get
+            {
+                return m_Sequence;
+            }
+            set
+            {
+                m_Sequence = value;
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool HasCompleted
+        {
+            get
+            {
+                if (m_Creatures.Count == 0)
+                    return false;
+
+                for (int i = 0; i < m_Creatures.Count; ++i)
+                {
+                    Mobile mob = m_Creatures[i];
+
+                    if (!mob.Deleted)
+                        return false;
+                }
+
+                return true;
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Rectangle2D RegionBounds
+        {
+            get
+            {
+                return m_RegionBounds;
+            }
+            set
+            {
+                m_RegionBounds = value;
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public GauntletSpawnerState State
+        {
+            get
+            {
+                return m_State;
+            }
+            set
+            {
+                if (m_State == value)
+                    return;
+
+                m_State = value;
+
+                int hue = 0;
+                bool lockDoors = (m_State == GauntletSpawnerState.InProgress);
+
+                switch ( m_State )
+                {
+                    case GauntletSpawnerState.InSequence:
+                        hue = InSequenceItemHue;
+                        break;
+                    case GauntletSpawnerState.InProgress:
+                        hue = InProgressItemHue;
+                        break;
+                    case GauntletSpawnerState.Completed:
+                        hue = CompletedItemHue;
+                        break;
+                }
+
+                if (m_Door != null)
+                {
+                    m_Door.Hue = hue;
+                    m_Door.Locked = lockDoors;
+
+                    if (lockDoors)
+                    {
+                        m_Door.KeyValue = Key.RandomValue();
+                        m_Door.Open = false;
+                    }
+
+                    if (m_Door.Link != null)
+                    {
+                        m_Door.Link.Hue = hue;
+                        m_Door.Link.Locked = lockDoors;
+
+                        if (lockDoors)
+                        {
+                            m_Door.Link.KeyValue = Key.RandomValue();
+                            m_Door.Open = false;
+                        }
+                    }
+                }
+
+                if (m_Addon != null)
+                    m_Addon.Hue = hue;
+
+                if (m_State == GauntletSpawnerState.InProgress)
+                {
+                    CreateRegion();
+                    FullSpawn();
+
+                    m_Timer = Timer.DelayCall(TimeSpan.FromSeconds(1.0), TimeSpan.FromSeconds(1.0), new TimerCallback(Slice));
+                }
+                else
+                {
+                    ClearCreatures();
+                    ClearTraps();
+                    DestroyRegion();
+
+                    if (m_Timer != null)
+                        m_Timer.Stop();
+
+                    m_Timer = null;
+                }
+            }
+        }
+
+        public List<Mobile> Creatures
+        {
+            get
+            {
+                return m_Creatures;
+            }
+            set
+            {
+                m_Creatures = value;
+            }
+        }
+
+        public List<BaseTrap> Traps
+        {
+            get
+            {
+                return m_Traps;
+            }
+            set
+            {
+                m_Traps = value;
+            }
+        }
+
+        public Region Region
+        {
+            get
+            {
+                return m_Region;
+            }
+            set
+            {
+                m_Region = value;
+            }
+        }
+
+        public override string DefaultName
+        {
+            get
+            {
+                return "doom spawner";
+            }
+        }
+
+        public static void Initialize()
+        {
+            CommandSystem.Register("GenGauntlet", AccessLevel.Administrator, new CommandEventHandler(GenGauntlet_OnCommand));
+			CommandSystem.Register("DeleteGauntlet", AccessLevel.Administrator, new CommandEventHandler(DeleteGauntlet_OnCommand));
+		}
+
+		private static bool FindObject<T>(Map map, Point3D p, int range, out T value) where T : IEntity
+		{
+			return FindObject(map, p, range, null, out value);
+		}
+
+		private static bool FindObject<T>(Map map, Point3D p, int range, Func<T, bool> predicate, out T value)
+			where T : IEntity
+		{
+			value = default(T);
+
+			var any = false;
+
+			var e = map.GetObjectsInRange(p, range);
+
+			foreach (var o in (predicate != null ? e.OfType<T>().Where(predicate) : e.OfType<T>()).Where(o => o != null))
+			{
+				value = o;
+				any = true;
+				break;
+			}
+
+			e.Free();
+
+			return any;
+		}
+
+		private static void DeleteDoor(BaseDoor d)
+		{
+			if (d == null)
+			{
+				return;
+			}
+
+			if (d.Link != null)
+			{
+				DeleteDoor(d.Link);
+			}
+
+			d.Delete();
+		}
+
+	    public static void CreateTeleporter(int xFrom, int yFrom, int xTo, int yTo)
+	    {
+		    var p = new Point3D(xFrom, yFrom, -1);
+
+		    Static telePad;
+
+		    if (FindObject(Map.Malas, p, 0, out telePad))
+		    {
+			    telePad.Delete();
+		    }
+
+		    telePad = new Static(0x1822);
+		    telePad.MoveToWorld(p, Map.Malas);
+		    telePad.Hue = 0x482;
+
+			WeakEntityCollection.Add("doom", telePad);
+
+		    Teleporter teleItem;
+
+		    if (FindObject(Map.Malas, p, 0, out teleItem))
+		    {
+			    teleItem.Delete();
+		    }
+
+			teleItem = new Teleporter(new Point3D(xTo, yTo, -1), Map.Malas, false);
+		    teleItem.MoveToWorld(p, Map.Malas);
+		    teleItem.SourceEffect = true;
+		    teleItem.DestEffect = true;
+		    teleItem.SoundID = 0x1FE;
+
+			WeakEntityCollection.Add("doom", teleItem);
+	    }
+
+	    public static BaseDoor CreateDoorSet(int xDoor, int yDoor, bool doorEastToWest, int hue)
+	    {
+		    var ph = new Point3D(xDoor, yDoor, -1);
+		    var pl = new Point3D(xDoor + (doorEastToWest ? 0 : 1), yDoor + (doorEastToWest ? 1 : 0), -1);
+
+		    BaseDoor hiDoor, loDoor;
+
+		    if (FindObject(Map.Malas, ph, 0, out hiDoor))
+		    {
+			    DeleteDoor(hiDoor);
+		    }
+
+			if (FindObject(Map.Malas, pl, 0, out loDoor))
+			{
+				DeleteDoor(loDoor);
+			}
+
+		    hiDoor = new MetalDoor(doorEastToWest ? DoorFacing.NorthCCW : DoorFacing.WestCW);
+			loDoor = new MetalDoor(doorEastToWest ? DoorFacing.SouthCW : DoorFacing.EastCCW);
+
+            hiDoor.MoveToWorld(ph, Map.Malas);
+            loDoor.MoveToWorld(pl, Map.Malas);
+
+            hiDoor.Link = loDoor;
+            loDoor.Link = hiDoor;
+
+            hiDoor.Hue = hue;
+            loDoor.Hue = hue;
+
+			WeakEntityCollection.Add("doom", hiDoor);
+			WeakEntityCollection.Add("doom", loDoor);
+
+            return hiDoor;
+		}
+
+	    public static GauntletSpawner CreateSpawner(
+		    string typeName,
+			    int xSpawner,
+			    int ySpawner,
+			    int xDoor,
+			    int yDoor,
+			    int xPentagram,
+			    int yPentagram,
+			    bool doorEastToWest,
+			    int xStart,
+			    int yStart,
+			    int xWidth,
+			    int yHeight)
+	    {
+		    var sp = new Point3D(xSpawner, ySpawner, -1);
+
+		    GauntletSpawner spawner;
+
+		    if (FindObject(Map.Malas, sp, 0, out spawner))
+		    {
+			    spawner.Delete();
+		    }
+
+		    spawner = new GauntletSpawner(typeName);
+			spawner.MoveToWorld(sp, Map.Malas);
+
+		    if (spawner.Door != null)
+		    {
+			    DeleteDoor(spawner.Door);
+		    }
+
+		    if (xDoor > 0 && yDoor > 0)
+		    {
+			    spawner.Door = CreateDoorSet(xDoor, yDoor, doorEastToWest, 0);
+		    }
+
+		    spawner.RegionBounds = new Rectangle2D(xStart, yStart, xWidth, yHeight);
+
+		    if (spawner.Addon != null)
+		    {
+			    spawner.Addon.Delete();
+			    spawner.Addon = null;
+		    }
+
+		    if (xPentagram > 0 && yPentagram > 0)
+		    {
+			    var pp = new Point3D(xPentagram, yPentagram, -1);
+
+			    PentagramAddon pentagram;
+
+			    if (FindObject(Map.Malas, pp, 0, out pentagram))
+			    {
+				    pentagram.Delete();
+			    }
+
+			    pentagram = new PentagramAddon();
+			    pentagram.MoveToWorld(pp, Map.Malas);
+
+				WeakEntityCollection.Add("doom", pentagram);
+
+			    spawner.Addon = pentagram;
+		    }
+
+			WeakEntityCollection.Add("doom", spawner);
+
+		    return spawner;
+	    }
+
+	    public static void CreatePricedHealer(int price, int x, int y)
+	    {
+		    var p = new Point3D(x, y, -1);
+
+		    PricedHealer healer;
+
+		    if (FindObject(Map.Malas, p, 10, out healer))
+		    {
+			    healer.Delete();
+		    }
+		    
+			healer = new PricedHealer(price);
+		    healer.MoveToWorld(p, Map.Malas);
+		    healer.Home = p;
+		    healer.RangeHome = 5;
+
+			WeakEntityCollection.Add("doom", healer);
+	    }
+
+	    public static void CreateMorphItem(int x, int y, int inactiveItemID, int activeItemID, int range, int hue)
+	    {
+		    var p = new Point3D(x, y, -1);
+
+		    MorphItem item;
+
+		    if (FindObject(Map.Malas, p, 0, out item))
+			{
+				item.Delete();
+		    }
+
+		    item = new MorphItem(inactiveItemID, activeItemID, range);
+			item.MoveToWorld(p, Map.Malas);
+			item.Hue = hue;
+
+			WeakEntityCollection.Add("doom", item);
+        }
+
+        public static void CreateVarietyDealer(int x, int y)
+        {
+	        var p = new Point3D(x, y, -1);
+
+            VarietyDealer dealer;
+
+	        if (FindObject(Map.Malas, p, 10, out dealer))
+	        {
+		        dealer.Delete();
+	        }
+
+	        dealer = new VarietyDealer
+	        {
+		        Name = "Nix",
+		        Title = "the Variety Dealer",
+		        Body = 400,
+		        Female = false,
+		        Hue = 0x8835
+	        };
+
+			WeakEntityCollection.Add("doom", dealer);
+
+	        /* Begin outfit */
+
+	        var ic = dealer.Items.Count;
+
+	        while (--ic >= 0)
+	        {
+		        if (ic >= dealer.Items.Count)
+		        {
+					continue;
+		        }
+
+		        var item = dealer.Items[ic];
+				
+                if (item.Layer != Layer.ShopBuy && item.Layer != Layer.ShopResale && item.Layer != Layer.ShopSell)
+                    item.Delete();
+            }
+
+            dealer.HairItemID = 0x2049; // Pig Tails
+            dealer.HairHue = 0x482;
+
+            dealer.FacialHairItemID = 0x203E;
+            dealer.FacialHairHue = 0x482;
+
+            dealer.AddItem(new FloppyHat(1));
+            dealer.AddItem(new Robe(1));
+
+            dealer.AddItem(new LanternOfSouls());
+
+            dealer.AddItem(new Sandals(0x482));
+            /* End outfit */
+
+            dealer.MoveToWorld(p, Map.Malas);
+
+            dealer.Home = p;
+            dealer.RangeHome = 2;
+        }
+
+		public static void DeleteGauntlet_OnCommand(CommandEventArgs e)
+		{
+			WeakEntityCollection.Delete("doom");
+		}
+
+        public static void GenGauntlet_OnCommand(CommandEventArgs e)
+		{
+			WeakEntityCollection.Delete("doom");
+
+            /* Begin healer room */
+            CreatePricedHealer(5000, 387, 400);
+            CreateTeleporter(390, 407, 394, 405);
+
+            BaseDoor healerDoor = CreateDoorSet(393, 404, true, 0x44E);
+
+            healerDoor.Locked = true;
+            healerDoor.KeyValue = Key.RandomValue();
+
+            if (healerDoor.Link != null)
+            {
+                healerDoor.Link.Locked = true;
+                healerDoor.Link.KeyValue = Key.RandomValue();
+            }
+            /* End healer room */
+
+            /* Begin supply room */
+            CreateMorphItem(433, 371, 0x29F, 0x116, 3, 0x44E);
+            CreateMorphItem(433, 372, 0x29F, 0x115, 3, 0x44E);
+
+            CreateVarietyDealer(492, 369);
+
+	        foreach (var s in Map.Malas.GetItemsInBounds(new Rectangle2D(434, 371, 44, 1)))
+	        {
+		        s.Delete();
+	        }
+
+	        for (int x = 434; x <= 478; ++x)
+            {
+	            for (int y = 371; y <= 372; ++y)
+	            {
+		            var item = new Static(0x524)
+		            {
+			            Hue = 1
+					};
+
+					item.MoveToWorld(new Point3D(x, y, -1), Map.Malas);
+
+					WeakEntityCollection.Add("doom", item);
+	            }
+            }
+            /* End supply room */
+
+            /* Begin gauntlet cycle */
+            CreateTeleporter(471, 428, 474, 428);
+            CreateTeleporter(462, 494, 462, 498);
+            CreateTeleporter(403, 502, 399, 506);
+            CreateTeleporter(357, 476, 356, 480);
+            CreateTeleporter(361, 433, 357, 434);
+
+            GauntletSpawner sp1 = CreateSpawner("DarknightCreeper", 491, 456, 473, 432, 417, 426, true, 473, 412, 39, 60);
+            GauntletSpawner sp2 = CreateSpawner("FleshRenderer", 482, 520, 468, 496, 426, 422, false, 448, 496, 56, 48);
+            GauntletSpawner sp3 = CreateSpawner("Impaler", 406, 538, 408, 504, 432, 430, false, 376, 504, 64, 48);
+            GauntletSpawner sp4 = CreateSpawner("ShadowKnight", 335, 512, 360, 478, 424, 439, false, 300, 478, 72, 64);
+            GauntletSpawner sp5 = CreateSpawner("AbysmalHorror", 326, 433, 360, 429, 416, 435, true, 300, 408, 60, 56);
+            GauntletSpawner sp6 = CreateSpawner("DemonKnight", 423, 430, 0, 0, 423, 430, true, 392, 392, 72, 96);
+
+            sp1.Sequence = sp2;
+            sp2.Sequence = sp3;
+            sp3.Sequence = sp4;
+            sp4.Sequence = sp5;
+            sp5.Sequence = sp6;
+            sp6.Sequence = sp1;
+
+            sp1.State = GauntletSpawnerState.InProgress;
+            /* End gauntlet cycle */
+
+            /* Begin exit gate */
+	        var p = new Point3D(433, 326, 4);
+
+            ConfirmationMoongate gate;
+
+	        if (FindObject(Map.Malas, p, 0, out gate))
+	        {
+		        gate.Delete();
+	        }
+
+	        gate = new ConfirmationMoongate
+	        {
+		        Dispellable = false,
+		        Target = new Point3D(2350, 1270, -85),
+		        TargetMap = Map.Malas,
+		        GumpWidth = 420,
+		        GumpHeight = 280,
+		        MessageColor = 0x7F00,
+		        MessageNumber = 1062109, // You are about to exit Dungeon Doom.  Do you wish to continue?
+		        TitleColor = 0x7800,
+		        TitleNumber = 1062108, // Please verify...
+		        Hue = 0x44E
+	        };
+
+	        gate.MoveToWorld(p, Map.Malas);
+
+			WeakEntityCollection.Add("doom", gate);
+            /* End exit gate */
+        }
+
+        public virtual void CreateRegion()
+        {
+            if (m_Region != null)
+                return;
+
+            Map map = Map;
+
+            if (map == null || map == Map.Internal)
+                return;
+
+            m_Region = new GauntletRegion(this, map);
+        }
+
+        public virtual void DestroyRegion()
+        {
+            if (m_Region != null)
+                m_Region.Unregister();
+
+            m_Region = null;
+        }
+
+        public virtual int ComputeTrapCount()
+        {
+            int area = m_RegionBounds.Width * m_RegionBounds.Height;
+
+            return area / 100;
+        }
+
+        public virtual void ClearTraps()
+        {
+            for (int i = 0; i < m_Traps.Count; ++i)
+                m_Traps[i].Delete();
+
+            m_Traps.Clear();
+        }
+
+        public virtual void SpawnTrap()
+        {
+            Map map = Map;
+
+            if (map == null)
+                return;
+
+            BaseTrap trap = null;
+
+            int random = Utility.Random(100);
+
+            if (22 > random)
+                trap = new SawTrap(Utility.RandomBool() ? SawTrapType.WestFloor : SawTrapType.NorthFloor);
+            else if (44 > random)
+                trap = new SpikeTrap(Utility.RandomBool() ? SpikeTrapType.WestFloor : SpikeTrapType.NorthFloor);
+            else if (66 > random)
+                trap = new GasTrap(Utility.RandomBool() ? GasTrapType.NorthWall : GasTrapType.WestWall);
+            else if (88 > random)
+                trap = new FireColumnTrap();
+            else
+                trap = new MushroomTrap();
+
+            if (trap == null)
+                return;
+
+            if (trap is FireColumnTrap || trap is MushroomTrap)
+                trap.Hue = 0x451;
+
+            // try 10 times to find a valid location
+            for (int i = 0; i < 10; ++i)
+            {
+                int x = Utility.Random(m_RegionBounds.X, m_RegionBounds.Width);
+                int y = Utility.Random(m_RegionBounds.Y, m_RegionBounds.Height);
+                int z = Z;
+
+                if (!map.CanFit(x, y, z, 16, false, false))
+                    z = map.GetAverageZ(x, y);
+
+                if (!map.CanFit(x, y, z, 16, false, false))
+                    continue;
+
+                trap.MoveToWorld(new Point3D(x, y, z), map);
+                m_Traps.Add(trap);
+
+                return;
+            }
+
+            trap.Delete();
+        }
+
+        public virtual int ComputeSpawnCount()
+        {
+            int playerCount = 0;
+
+            Map map = Map;
+
+            if (map != null)
+            {
+                Point3D loc = GetWorldLocation();
+
+                Region reg = Region.Find(loc, map).GetRegion("Doom Gauntlet");
+
+                if (reg != null)
+                    playerCount = reg.GetEnumeratedMobiles().Where(m => m is PlayerMobile && m.AccessLevel == AccessLevel.Player).Count();
+            }
+
+            if (playerCount == 0 && m_Region != null)
+                playerCount = m_Region.GetEnumeratedMobiles().Where(m => m.AccessLevel == AccessLevel.Player).Count();
+
+            int count = (playerCount + PlayersPerSpawn - 1) / PlayersPerSpawn;
+
+            if (count < 1)
+                count = 1;
+
+            return count;
+        }
+
+        public virtual void ClearCreatures()
+        {
+            for (int i = 0; i < m_Creatures.Count; ++i)
+                m_Creatures[i].Delete();
+
+            m_Creatures.Clear();
+        }
+
+        public virtual void FullSpawn()
+        {
+            ClearCreatures();
+
+            int count = ComputeSpawnCount();
+
+            for (int i = 0; i < count; ++i)
+                Spawn();
+
+            ClearTraps();
+
+            count = ComputeTrapCount();
+
+            for (int i = 0; i < count; ++i)
+                SpawnTrap();
+        }
+
+        public virtual void Spawn()
+        {
+            try
+            {
+                if (m_TypeName == null)
+                    return;
+
+                Type type = ScriptCompiler.FindTypeByName(m_TypeName, true);
+
+                if (type == null)
+                    return;
+
+                object obj = Activator.CreateInstance(type);
+
+                if (obj == null)
+                    return;
+
+                if (obj is Item)
+                {
+                    ((Item)obj).Delete();
+                }
+                else if (obj is Mobile)
+                {
+                    Mobile mob = (Mobile)obj;
+
+                    mob.MoveToWorld(GetWorldLocation(), Map);
+
+                    m_Creatures.Add(mob);
+                }
+            }
+            catch
+            {
+            }
+        }
+
+        public virtual void RecurseReset()
+        {
+            if (m_State != GauntletSpawnerState.InSequence)
+            {
+                State = GauntletSpawnerState.InSequence;
+
+                if (m_Sequence != null && !m_Sequence.Deleted)
+                    m_Sequence.RecurseReset();
+            }
+        }
+
+        public virtual void Slice()
+        {
+            if (m_State != GauntletSpawnerState.InProgress)
+                return;
+
+            int count = ComputeSpawnCount();
+
+            for (int i = m_Creatures.Count; i < count; ++i)
+                Spawn();
+
+            if (HasCompleted)
+            {
+                State = GauntletSpawnerState.Completed;
+
+                if (m_Sequence != null && !m_Sequence.Deleted)
+                {
+                    if (m_Sequence.State == GauntletSpawnerState.Completed)
+                        RecurseReset();
+
+                    m_Sequence.State = GauntletSpawnerState.InProgress;
+                }
+            }
+        }
+
+        public override void Delete()
+        {
+            ClearCreatures();
+            ClearTraps();
+            DestroyRegion();
+
+            if (m_Timer != null)
+                m_Timer.Stop();
+
+            m_Timer = null;
+
+            base.Delete();
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1); // version
+
+            writer.Write(m_RegionBounds);
+
+            writer.WriteItemList<BaseTrap>(m_Traps, false);
+
+            writer.Write(m_Creatures, false);
+
+            writer.Write(m_TypeName);
+            writer.WriteItem<BaseDoor>(m_Door);
+            writer.WriteItem<BaseAddon>(m_Addon);
+            writer.WriteItem<GauntletSpawner>(m_Sequence);
+
+            writer.Write((int)m_State);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 1:
+                    {
+                        m_RegionBounds = reader.ReadRect2D();
+                        m_Traps = reader.ReadStrongItemList<BaseTrap>();
+
+                        goto case 0;
+                    }
+                case 0:
+                    {
+                        if (version < 1)
+                        {
+                            m_Traps = new List<BaseTrap>();
+                            m_RegionBounds = new Rectangle2D(X - 40, Y - 40, 80, 80);
+                        }
+
+                        m_Creatures = reader.ReadStrongMobileList();
+
+                        m_TypeName = reader.ReadString();
+                        m_Door = reader.ReadItem<BaseDoor>(); 
+                        m_Addon = reader.ReadItem<BaseAddon>(); 
+                        m_Sequence = reader.ReadItem<GauntletSpawner>();
+
+                        State = (GauntletSpawnerState)reader.ReadInt();
+
+                        break;
+                    }
+            }
+        }
+    }
+
+    public class GauntletRegion : BaseRegion
+    {
+        private readonly GauntletSpawner m_Spawner;
+        public GauntletRegion(GauntletSpawner spawner, Map map)
+            : base(null, map, Region.Find(spawner.Location, spawner.Map), spawner.RegionBounds)
+        {
+            m_Spawner = spawner;
+
+            GoLocation = spawner.Location;
+
+            Register();
+        }
+
+        public override void AlterLightLevel(Mobile m, ref int global, ref int personal)
+        {
+            global = 12;
+        }
+
+        public override void OnEnter(Mobile m)
+        {
+        }
+
+        public override void OnExit(Mobile m)
+        {
+        }
+    }
+}