Overwrite

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

Scripts/Regions/Spawning/SpawnDefinition.cs

@@ -0,0 +1,482 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Xml;
+using Server.Items;
+using Server.Mobiles;
+
+namespace Server.Regions
+{
+    public abstract class SpawnDefinition
+    {
+        protected SpawnDefinition()
+        {
+        }
+
+        public static SpawnDefinition GetSpawnDefinition(XmlElement xml)
+        {
+            switch ( xml.Name )
+            {
+                case "object":
+                    {
+                        Type type = null;
+                        if (!Region.ReadType(xml, "type", ref type))
+                            return null;
+
+                        if (typeof(Mobile).IsAssignableFrom(type))
+                        {
+                            return SpawnMobile.Get(type);
+                        }
+                        else if (typeof(Item).IsAssignableFrom(type))
+                        {
+                            return SpawnItem.Get(type);
+                        }
+                        else
+                        {
+                            Console.WriteLine("Invalid type '{0}' in a SpawnDefinition", type.FullName);
+                            return null;
+                        }
+                    }
+                case "group":
+                    {
+                        string group = null;
+                        if (!Region.ReadString(xml, "name", ref group))
+                            return null;
+
+                        SpawnDefinition def = (SpawnDefinition)SpawnGroup.Table[group];
+
+                        if (def == null)
+                        {
+                            Console.WriteLine("Could not find group '{0}' in a SpawnDefinition", group);
+                            return null;
+                        }
+                        else
+                        {
+                            return def;
+                        }
+                    }
+                case "treasureChest":
+                    {
+                        int itemID = 0xE43;
+                        Region.ReadInt32(xml, "itemID", ref itemID, false);
+
+                        BaseTreasureChest.TreasureLevel level = BaseTreasureChest.TreasureLevel.Level2;
+
+                        Region.ReadEnum(xml, "level", ref level, false);
+
+                        return new SpawnTreasureChest(itemID, level);
+                    }
+                default:
+                    {
+                        return null;
+                    }
+            }
+        }
+
+        public abstract ISpawnable Spawn(SpawnEntry entry);
+
+        public abstract bool CanSpawn(params Type[] types);
+    }
+
+    public abstract class SpawnType : SpawnDefinition
+    {
+        private readonly Type m_Type;
+        private bool m_Init;
+        protected SpawnType(Type type)
+        {
+            this.m_Type = type;
+            this.m_Init = false;
+        }
+
+        public Type Type
+        {
+            get
+            {
+                return this.m_Type;
+            }
+        }
+        public abstract int Height { get; }
+        public abstract bool Land { get; }
+        public abstract bool Water { get; }
+        public override ISpawnable Spawn(SpawnEntry entry)
+        {
+            BaseRegion region = entry.Region;
+            Map map = region.Map;
+
+            Point3D loc = entry.RandomSpawnLocation(this.Height, this.Land, this.Water);
+
+            if (loc == Point3D.Zero)
+                return null;
+
+            return this.Construct(entry, loc, map);
+        }
+
+        public override bool CanSpawn(params Type[] types)
+        {
+            for (int i = 0; i < types.Length; i++)
+            {
+                if (types[i] == this.m_Type)
+                    return true;
+            }
+
+            return false;
+        }
+
+        protected void EnsureInit()
+        {
+            if (this.m_Init)
+                return;
+
+            this.Init();
+            this.m_Init = true;
+        }
+
+        protected virtual void Init()
+        {
+        }
+
+        protected abstract ISpawnable Construct(SpawnEntry entry, Point3D loc, Map map);
+    }
+
+    public class SpawnMobile : SpawnType
+    {
+        protected bool m_Land;
+        protected bool m_Water;
+        private static readonly Hashtable m_Table = new Hashtable();
+        protected SpawnMobile(Type type)
+            : base(type)
+        {
+        }
+
+        public override int Height
+        {
+            get
+            {
+                return 16;
+            }
+        }
+        public override bool Land
+        {
+            get
+            {
+                this.EnsureInit();
+                return this.m_Land;
+            }
+        }
+        public override bool Water
+        {
+            get
+            {
+                this.EnsureInit();
+                return this.m_Water;
+            }
+        }
+        public static SpawnMobile Get(Type type)
+        {
+            SpawnMobile sm = (SpawnMobile)m_Table[type];
+
+            if (sm == null)
+            {
+                sm = new SpawnMobile(type);
+                m_Table[type] = sm;
+            }
+
+            return sm;
+        }
+
+        protected override void Init()
+        {
+            Mobile mob = (Mobile)Activator.CreateInstance(this.Type);
+
+            this.m_Land = !mob.CantWalk;
+            this.m_Water = mob.CanSwim;
+
+            mob.Delete();
+        }
+
+        protected override ISpawnable Construct(SpawnEntry entry, Point3D loc, Map map)
+        {
+            Mobile mobile = this.CreateMobile();
+
+            BaseCreature creature = mobile as BaseCreature;
+
+            if (creature != null)
+            {
+                creature.Home = entry.HomeLocation;
+                creature.RangeHome = entry.HomeRange;
+            }
+
+            if (entry.Direction != SpawnEntry.InvalidDirection)
+                mobile.Direction = entry.Direction;
+
+            mobile.OnBeforeSpawn(loc, map);
+            mobile.MoveToWorld(loc, map);
+            mobile.OnAfterSpawn();
+
+            return mobile;
+        }
+
+        protected virtual Mobile CreateMobile()
+        {
+            return (Mobile)Activator.CreateInstance(this.Type);
+        }
+    }
+
+    public class SpawnItem : SpawnType
+    {
+        protected int m_Height;
+        private static readonly Hashtable m_Table = new Hashtable();
+        protected SpawnItem(Type type)
+            : base(type)
+        {
+        }
+
+        public override int Height
+        {
+            get
+            {
+                this.EnsureInit();
+                return this.m_Height;
+            }
+        }
+        public override bool Land
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override bool Water
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public static SpawnItem Get(Type type)
+        {
+            SpawnItem si = (SpawnItem)m_Table[type];
+
+            if (si == null)
+            {
+                si = new SpawnItem(type);
+                m_Table[type] = si;
+            }
+
+            return si;
+        }
+
+        protected override void Init()
+        {
+            Item item = (Item)Activator.CreateInstance(this.Type);
+
+            this.m_Height = item.ItemData.Height;
+
+            item.Delete();
+        }
+
+        protected override ISpawnable Construct(SpawnEntry entry, Point3D loc, Map map)
+        {
+            Item item = this.CreateItem();
+
+            item.OnBeforeSpawn(loc, map);
+            item.MoveToWorld(loc, map);
+            item.OnAfterSpawn();
+
+            return item;
+        }
+
+        protected virtual Item CreateItem()
+        {
+            return (Item)Activator.CreateInstance(this.Type);
+        }
+    }
+
+    public class SpawnTreasureChest : SpawnItem
+    {
+        private readonly int m_ItemID;
+        private readonly BaseTreasureChest.TreasureLevel m_Level;
+        public SpawnTreasureChest(int itemID, BaseTreasureChest.TreasureLevel level)
+            : base(typeof(BaseTreasureChest))
+        {
+            this.m_ItemID = itemID;
+            this.m_Level = level;
+        }
+
+        public int ItemID
+        {
+            get
+            {
+                return this.m_ItemID;
+            }
+        }
+        public BaseTreasureChest.TreasureLevel Level
+        {
+            get
+            {
+                return this.m_Level;
+            }
+        }
+        protected override void Init()
+        {
+            this.m_Height = TileData.ItemTable[this.m_ItemID & TileData.MaxItemValue].Height;
+        }
+
+        protected override Item CreateItem()
+        {
+            return new BaseTreasureChest(this.m_ItemID, this.m_Level);
+        }
+    }
+
+    public class SpawnGroupElement
+    {
+        private readonly SpawnDefinition m_SpawnDefinition;
+        private readonly int m_Weight;
+        public SpawnGroupElement(SpawnDefinition spawnDefinition, int weight)
+        {
+            this.m_SpawnDefinition = spawnDefinition;
+            this.m_Weight = weight;
+        }
+
+        public SpawnDefinition SpawnDefinition
+        {
+            get
+            {
+                return this.m_SpawnDefinition;
+            }
+        }
+        public int Weight
+        {
+            get
+            {
+                return this.m_Weight;
+            }
+        }
+    }
+
+    public class SpawnGroup : SpawnDefinition
+    {
+        private static readonly Hashtable m_Table = new Hashtable();
+        private readonly string m_Name;
+        private readonly SpawnGroupElement[] m_Elements;
+        private readonly int m_TotalWeight;
+        public SpawnGroup(string name, SpawnGroupElement[] elements)
+        {
+            this.m_Name = name;
+            this.m_Elements = elements;
+
+            this.m_TotalWeight = 0;
+            for (int i = 0; i < elements.Length; i++)
+                this.m_TotalWeight += elements[i].Weight;
+        }
+
+        static SpawnGroup()
+        {
+            string path = Path.Combine(Core.BaseDirectory, "Data/SpawnDefinitions.xml");
+            if (!File.Exists(path))
+                return;
+
+            try
+            {
+                XmlDocument doc = new XmlDocument();
+                doc.Load(path);
+
+                XmlElement root = doc["spawnDefinitions"];
+                if (root == null)
+                    return;
+
+                foreach (XmlElement xmlDef in root.SelectNodes("spawnGroup"))
+                {
+                    string name = null;
+                    if (!Region.ReadString(xmlDef, "name", ref name))
+                        continue;
+
+                    List<SpawnGroupElement> list = new List<SpawnGroupElement>();
+                    foreach (XmlNode node in xmlDef.ChildNodes)
+                    {
+                        XmlElement el = node as XmlElement;
+
+                        if (el != null)
+                        {
+                            SpawnDefinition def = GetSpawnDefinition(el);
+                            if (def == null)
+                                continue;
+
+                            int weight = 1;
+                            Region.ReadInt32(el, "weight", ref weight, false);
+
+                            SpawnGroupElement groupElement = new SpawnGroupElement(def, weight);
+                            list.Add(groupElement);
+                        }
+                    }
+
+                    SpawnGroupElement[] elements = list.ToArray();
+                    SpawnGroup group = new SpawnGroup(name, elements);
+                    Register(group);
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("Could not load SpawnDefinitions.xml: " + ex.Message);
+            }
+        }
+
+        public static Hashtable Table
+        {
+            get
+            {
+                return m_Table;
+            }
+        }
+        public string Name
+        {
+            get
+            {
+                return this.m_Name;
+            }
+        }
+        public SpawnGroupElement[] Elements
+        {
+            get
+            {
+                return this.m_Elements;
+            }
+        }
+        public static void Register(SpawnGroup group)
+        {
+            if (m_Table.Contains(group.Name))
+                Console.WriteLine("Warning: Double SpawnGroup name '{0}'", group.Name);
+            else
+                m_Table[group.Name] = group;
+        }
+
+        public override ISpawnable Spawn(SpawnEntry entry)
+        {
+            int index = Utility.Random(this.m_TotalWeight);
+
+            for (int i = 0; i < this.m_Elements.Length; i++)
+            {
+                SpawnGroupElement element = this.m_Elements[i];
+
+                if (index < element.Weight)
+                    return element.SpawnDefinition.Spawn(entry);
+
+                index -= element.Weight;
+            }
+
+            return null;
+        }
+
+        public override bool CanSpawn(params Type[] types)
+        {
+            for (int i = 0; i < this.m_Elements.Length; i++)
+            {
+                if (this.m_Elements[i].SpawnDefinition.CanSpawn(types))
+                    return true;
+            }
+
+            return false;
+        }
+    }
+}

Scripts/Regions/Spawning/SpawnEntry.cs

@@ -0,0 +1,560 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server.Commands;
+using Server.ContextMenus;
+using Server.Mobiles;
+
+namespace Server.Regions
+{
+    public class SpawnEntry : ISpawner
+    {
+        public static readonly TimeSpan DefaultMinSpawnTime = TimeSpan.FromMinutes(2.0);
+        public static readonly TimeSpan DefaultMaxSpawnTime = TimeSpan.FromMinutes(5.0);
+        public static readonly Direction InvalidDirection = Direction.Running;
+        private static readonly Hashtable m_Table = new Hashtable();
+        private static List<IEntity> m_RemoveList;
+        private readonly int m_ID;
+        private readonly BaseRegion m_Region;
+        private readonly Point3D m_Home;
+        private readonly int m_Range;
+        private readonly Direction m_Direction;
+        private readonly SpawnDefinition m_Definition;
+        private readonly List<ISpawnable> m_SpawnedObjects;
+        private readonly TimeSpan m_MinSpawnTime;
+        private readonly TimeSpan m_MaxSpawnTime;
+        private int m_Max;
+        private bool m_Running;
+        private DateTime m_NextSpawn;
+        private Timer m_SpawnTimer;
+        public SpawnEntry(int id, BaseRegion region, Point3D home, int range, Direction direction, SpawnDefinition definition, int max, TimeSpan minSpawnTime, TimeSpan maxSpawnTime)
+        {
+            this.m_ID = id;
+            this.m_Region = region;
+            this.m_Home = home;
+            this.m_Range = range;
+            this.m_Direction = direction;
+            this.m_Definition = definition;
+            this.m_SpawnedObjects = new List<ISpawnable>();
+            this.m_Max = max;
+            this.m_MinSpawnTime = minSpawnTime;
+            this.m_MaxSpawnTime = maxSpawnTime;
+            this.m_Running = false;
+
+            if (m_Table.Contains(id))
+                Console.WriteLine("Warning: double SpawnEntry ID '{0}'", id);
+            else
+                m_Table[id] = this;
+        }
+
+        public static Hashtable Table
+        {
+            get
+            {
+                return m_Table;
+            }
+        }
+        // When a creature's AI is deactivated (PlayerRangeSensitive optimization) does it return home?
+        public bool ReturnOnDeactivate
+        {
+            get
+            {
+                return true;
+            }
+        }
+        // Are creatures unlinked on taming (true) or should they also go out of the region (false)?
+        public bool UnlinkOnTaming
+        {
+            get
+            {
+                return false;
+            }
+        }
+        // Are unlinked and untamed creatures removed after 20 hours?
+        public bool RemoveIfUntamed
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public int ID
+        {
+            get
+            {
+                return this.m_ID;
+            }
+        }
+        public BaseRegion Region
+        {
+            get
+            {
+                return this.m_Region;
+            }
+        }
+        public Point3D HomeLocation
+        {
+            get
+            {
+                return this.m_Home;
+            }
+        }
+        public int HomeRange
+        {
+            get
+            {
+                return this.m_Range;
+            }
+        }
+        public Direction Direction
+        {
+            get
+            {
+                return this.m_Direction;
+            }
+        }
+        public SpawnDefinition Definition
+        {
+            get
+            {
+                return this.m_Definition;
+            }
+        }
+        public List<ISpawnable> SpawnedObjects
+        {
+            get
+            {
+                return this.m_SpawnedObjects;
+            }
+        }
+        public int Max
+        {
+            get
+            {
+                return this.m_Max;
+            }
+        }
+        public TimeSpan MinSpawnTime
+        {
+            get
+            {
+                return this.m_MinSpawnTime;
+            }
+        }
+        public TimeSpan MaxSpawnTime
+        {
+            get
+            {
+                return this.m_MaxSpawnTime;
+            }
+        }
+        public bool Running
+        {
+            get
+            {
+                return this.m_Running;
+            }
+        }
+        public bool Complete
+        {
+            get
+            {
+                return this.m_SpawnedObjects.Count >= this.m_Max;
+            }
+        }
+        public bool Spawning
+        {
+            get
+            {
+                return this.m_Running && !this.Complete;
+            }
+        }
+
+        public virtual void GetSpawnProperties(ISpawnable spawn, ObjectPropertyList list)
+        { }
+
+        public virtual void GetSpawnContextEntries(ISpawnable spawn, Mobile m, List<ContextMenuEntry> list)
+        { }
+
+        public static void Remove(GenericReader reader, int version)
+        {
+            int count = reader.ReadInt();
+
+            for (int i = 0; i < count; i++)
+            {
+                int serial = reader.ReadInt();
+                IEntity entity = World.FindEntity(serial);
+
+                if (entity != null)
+                {
+                    if (m_RemoveList == null)
+                        m_RemoveList = new List<IEntity>();
+
+                    m_RemoveList.Add(entity);
+                }
+            }
+
+            reader.ReadBool(); // m_Running
+
+            if (reader.ReadBool())
+                reader.ReadDeltaTime(); // m_NextSpawn
+        }
+
+        public static void Initialize()
+        {
+            if (m_RemoveList != null)
+            {
+                foreach (IEntity ent in m_RemoveList)
+                {
+                    ent.Delete();
+                }
+
+                m_RemoveList = null;
+            }
+
+            SpawnPersistence.EnsureExistence();
+
+            CommandSystem.Register("RespawnAllRegions", AccessLevel.Administrator, new CommandEventHandler(RespawnAllRegions_OnCommand));
+            CommandSystem.Register("RespawnRegion", AccessLevel.GameMaster, new CommandEventHandler(RespawnRegion_OnCommand));
+            CommandSystem.Register("DelAllRegionSpawns", AccessLevel.Administrator, new CommandEventHandler(DelAllRegionSpawns_OnCommand));
+            CommandSystem.Register("DelRegionSpawns", AccessLevel.GameMaster, new CommandEventHandler(DelRegionSpawns_OnCommand));
+            CommandSystem.Register("StartAllRegionSpawns", AccessLevel.Administrator, new CommandEventHandler(StartAllRegionSpawns_OnCommand));
+            CommandSystem.Register("StartRegionSpawns", AccessLevel.GameMaster, new CommandEventHandler(StartRegionSpawns_OnCommand));
+            CommandSystem.Register("StopAllRegionSpawns", AccessLevel.Administrator, new CommandEventHandler(StopAllRegionSpawns_OnCommand));
+            CommandSystem.Register("StopRegionSpawns", AccessLevel.GameMaster, new CommandEventHandler(StopRegionSpawns_OnCommand));
+        }
+
+        public Point3D RandomSpawnLocation(int spawnHeight, bool land, bool water)
+        {
+            return this.m_Region.RandomSpawnLocation(spawnHeight, land, water, this.m_Home, this.m_Range);
+        }
+
+        public void Start()
+        {
+            if (this.m_Running)
+                return;
+
+            this.m_Running = true;
+            this.CheckTimer();
+        }
+
+        public void Stop()
+        {
+            if (!this.m_Running)
+                return;
+
+            this.m_Running = false;
+            this.CheckTimer();
+        }
+
+        public void DeleteSpawnedObjects()
+        {
+            this.InternalDeleteSpawnedObjects();
+
+            this.m_Running = false;
+            this.CheckTimer();
+        }
+
+        public void Respawn()
+        {
+            this.InternalDeleteSpawnedObjects();
+
+            for (int i = 0; !this.Complete && i < this.m_Max; i++)
+                this.Spawn();
+
+            this.m_Running = true;
+            this.CheckTimer();
+        }
+
+        public void Delete()
+        {
+            this.m_Max = 0;
+            this.InternalDeleteSpawnedObjects();
+
+            if (this.m_SpawnTimer != null)
+            {
+                this.m_SpawnTimer.Stop();
+                this.m_SpawnTimer = null;
+            }
+
+            if (m_Table[this.m_ID] == this)
+                m_Table.Remove(this.m_ID);
+        }
+
+        public void Serialize(GenericWriter writer)
+        {
+            writer.Write((int)this.m_SpawnedObjects.Count);
+
+            for (int i = 0; i < this.m_SpawnedObjects.Count; i++)
+            {
+                ISpawnable spawn = this.m_SpawnedObjects[i];
+
+                int serial = spawn.Serial;
+
+                writer.Write((int)serial);
+            }
+
+            writer.Write((bool)this.m_Running);
+
+            if (this.m_SpawnTimer != null)
+            {
+                writer.Write(true);
+                writer.WriteDeltaTime((DateTime)this.m_NextSpawn);
+            }
+            else
+            {
+                writer.Write(false);
+            }
+        }
+
+        public void Deserialize(GenericReader reader, int version)
+        {
+            int count = reader.ReadInt();
+
+            for (int i = 0; i < count; i++)
+            {
+                int serial = reader.ReadInt();
+                ISpawnable spawnableEntity = World.FindEntity(serial) as ISpawnable;
+
+                if (spawnableEntity != null)
+                    this.Add(spawnableEntity);
+            }
+
+            this.m_Running = reader.ReadBool();
+
+            if (reader.ReadBool())
+            {
+                this.m_NextSpawn = reader.ReadDeltaTime();
+
+                if (this.Spawning)
+                {
+                    if (this.m_SpawnTimer != null)
+                        this.m_SpawnTimer.Stop();
+
+                    TimeSpan delay = this.m_NextSpawn - DateTime.UtcNow;
+                    this.m_SpawnTimer = Timer.DelayCall(delay > TimeSpan.Zero ? delay : TimeSpan.Zero, new TimerCallback(TimerCallback)); 
+                }
+            }
+
+            this.CheckTimer();
+        }
+
+        private static BaseRegion GetCommandData(CommandEventArgs args)
+        {
+            Mobile from = args.Mobile;
+
+            Region reg;
+            if (args.Length == 0)
+            {
+                reg = from.Region;
+            }
+            else
+            {
+                string name = args.GetString(0);
+                //reg = (Region) from.Map.Regions[name];
+
+                if (!from.Map.Regions.TryGetValue(name, out reg))
+                {
+                    from.SendMessage("Could not find region '{0}'.", name);
+                    return null;
+                }
+            }
+
+            BaseRegion br = reg as BaseRegion;
+
+            if (br == null || br.Spawns == null)
+            {
+                from.SendMessage("There are no spawners in region '{0}'.", reg);
+                return null;
+            }
+
+            return br;
+        }
+
+        [Usage("RespawnAllRegions")]
+        [Description("Respawns all regions and sets the spawners as running.")]
+        private static void RespawnAllRegions_OnCommand(CommandEventArgs args)
+        {
+            foreach (SpawnEntry entry in m_Table.Values)
+            {
+                entry.Respawn();
+            }
+
+            args.Mobile.SendMessage("All regions have respawned.");
+        }
+
+        [Usage("RespawnRegion [<region name>]")]
+        [Description("Respawns the region in which you are (or that you provided) and sets the spawners as running.")]
+        private static void RespawnRegion_OnCommand(CommandEventArgs args)
+        {
+            BaseRegion region = GetCommandData(args);
+
+            if (region == null)
+                return;
+
+            for (int i = 0; i < region.Spawns.Length; i++)
+                region.Spawns[i].Respawn();
+
+            args.Mobile.SendMessage("Region '{0}' has respawned.", region);
+        }
+
+        [Usage("DelAllRegionSpawns")]
+        [Description("Deletes all spawned objects of every regions and sets the spawners as not running.")]
+        private static void DelAllRegionSpawns_OnCommand(CommandEventArgs args)
+        {
+            foreach (SpawnEntry entry in m_Table.Values)
+            {
+                entry.DeleteSpawnedObjects();
+            }
+
+            args.Mobile.SendMessage("All region spawned objects have been deleted.");
+        }
+
+        [Usage("DelRegionSpawns [<region name>]")]
+        [Description("Deletes all spawned objects of the region in which you are (or that you provided) and sets the spawners as not running.")]
+        private static void DelRegionSpawns_OnCommand(CommandEventArgs args)
+        {
+            BaseRegion region = GetCommandData(args);
+
+            if (region == null)
+                return;
+
+            for (int i = 0; i < region.Spawns.Length; i++)
+                region.Spawns[i].DeleteSpawnedObjects();
+
+            args.Mobile.SendMessage("Spawned objects of region '{0}' have been deleted.", region);
+        }
+
+        [Usage("StartAllRegionSpawns")]
+        [Description("Sets the region spawners of all regions as running.")]
+        private static void StartAllRegionSpawns_OnCommand(CommandEventArgs args)
+        {
+            foreach (SpawnEntry entry in m_Table.Values)
+            {
+                entry.Start();
+            }
+
+            args.Mobile.SendMessage("All region spawners have started.");
+        }
+
+        [Usage("StartRegionSpawns [<region name>]")]
+        [Description("Sets the region spawners of the region in which you are (or that you provided) as running.")]
+        private static void StartRegionSpawns_OnCommand(CommandEventArgs args)
+        {
+            BaseRegion region = GetCommandData(args);
+
+            if (region == null)
+                return;
+
+            for (int i = 0; i < region.Spawns.Length; i++)
+                region.Spawns[i].Start();
+
+            args.Mobile.SendMessage("Spawners of region '{0}' have started.", region);
+        }
+
+        [Usage("StopAllRegionSpawns")]
+        [Description("Sets the region spawners of all regions as not running.")]
+        private static void StopAllRegionSpawns_OnCommand(CommandEventArgs args)
+        {
+            foreach (SpawnEntry entry in m_Table.Values)
+            {
+                entry.Stop();
+            }
+
+            args.Mobile.SendMessage("All region spawners have stopped.");
+        }
+
+        [Usage("StopRegionSpawns [<region name>]")]
+        [Description("Sets the region spawners of the region in which you are (or that you provided) as not running.")]
+        private static void StopRegionSpawns_OnCommand(CommandEventArgs args)
+        {
+            BaseRegion region = GetCommandData(args);
+
+            if (region == null)
+                return;
+
+            for (int i = 0; i < region.Spawns.Length; i++)
+                region.Spawns[i].Stop();
+
+            args.Mobile.SendMessage("Spawners of region '{0}' have stopped.", region);
+        }
+
+        private void Spawn()
+        {
+            ISpawnable spawn = this.m_Definition.Spawn(this);
+
+            if (spawn != null)
+                this.Add(spawn);
+        }
+
+        private void Add(ISpawnable spawn)
+        {
+            this.m_SpawnedObjects.Add(spawn);
+
+            spawn.Spawner = this;
+
+            if (spawn is BaseCreature)
+                ((BaseCreature)spawn).RemoveIfUntamed = this.RemoveIfUntamed;
+        }
+
+        void ISpawner.Remove(ISpawnable spawn)
+        {
+            this.m_SpawnedObjects.Remove(spawn);
+
+            this.CheckTimer();
+        }
+
+        private TimeSpan RandomTime()
+        {
+            int min = (int)this.m_MinSpawnTime.TotalSeconds;
+            int max = (int)this.m_MaxSpawnTime.TotalSeconds;
+
+            int rand = Utility.RandomMinMax(min, max);
+            return TimeSpan.FromSeconds(rand);
+        }
+
+        private void CheckTimer()
+        {
+            if (this.Spawning)
+            {
+                if (this.m_SpawnTimer == null)
+                {
+                    TimeSpan time = this.RandomTime();
+                    this.m_SpawnTimer = Timer.DelayCall(time, new TimerCallback(TimerCallback));
+                    this.m_NextSpawn = DateTime.UtcNow + time;
+                }
+            }
+            else if (this.m_SpawnTimer != null)
+            {
+                this.m_SpawnTimer.Stop();
+                this.m_SpawnTimer = null;
+            }
+        }
+
+        private void TimerCallback()
+        {
+            int amount = Math.Max((this.m_Max - this.m_SpawnedObjects.Count) / 3, 1);
+
+            for (int i = 0; i < amount; i++)
+                this.Spawn();
+
+            this.m_SpawnTimer = null;
+            this.CheckTimer();
+        }
+
+        private void InternalDeleteSpawnedObjects()
+        {
+            foreach (ISpawnable spawnable in this.m_SpawnedObjects)
+            {
+                spawnable.Spawner = null;
+
+                bool uncontrolled = !(spawnable is BaseCreature) || !((BaseCreature)spawnable).Controlled;
+
+                if (uncontrolled)
+                    spawnable.Delete();
+            }
+
+            this.m_SpawnedObjects.Clear();
+        }
+    }
+}

Scripts/Regions/Spawning/SpawnPersistence.cs

@@ -0,0 +1,75 @@
+using System;
+
+namespace Server.Regions
+{
+    public class SpawnPersistence : Item
+    {
+        private static SpawnPersistence m_Instance;
+        public SpawnPersistence(Serial serial)
+            : base(serial)
+        {
+            m_Instance = this;
+        }
+
+        private SpawnPersistence()
+            : base(1)
+        {
+            this.Movable = false;
+        }
+
+        public SpawnPersistence Instance
+        {
+            get
+            {
+                return m_Instance;
+            }
+        }
+        public override string DefaultName
+        {
+            get
+            {
+                return "Region spawn persistence - Internal";
+            }
+        }
+        public static void EnsureExistence()
+        {
+            if (m_Instance == null)
+                m_Instance = new SpawnPersistence();
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+
+            writer.Write((int)SpawnEntry.Table.Values.Count);
+            foreach (SpawnEntry entry in SpawnEntry.Table.Values)
+            {
+                writer.Write((int)entry.ID);
+
+                entry.Serialize(writer);
+            }
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+
+            int count = reader.ReadInt();
+            for (int i = 0; i < count; i++)
+            {
+                int id = reader.ReadInt();
+
+                SpawnEntry entry = (SpawnEntry)SpawnEntry.Table[id];
+
+                if (entry != null)
+                    entry.Deserialize(reader, version);
+                else
+                    SpawnEntry.Remove(reader, version);
+            }
+        }
+    }
+}