Overwrite

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

Scripts/Services/XmlSpawner/XMLSpawner Support/BaseArtifact.cs

@@ -0,0 +1,49 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+	public abstract class Artifact : Item, IArtifact
+	{
+		[Constructable]
+		public Artifact(int itemID) : base(itemID)
+		{
+		}
+
+		public Artifact( Serial serial ) : base( serial )
+		{
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public virtual int ArtifactRarity
+		{ 
+			get{ return 0; }
+			set {}
+		}
+
+		public override bool ForceShowProperties{ get{ return true; } }
+            
+		public override void GetProperties( ObjectPropertyList list )
+		{
+			base.GetProperties( list );
+			if(ArtifactRarity > 0)
+				list.Add( 1061078, ArtifactRarity.ToString() );
+		}
+
+		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/XmlSpawner/XMLSpawner Support/SimpleArtifact.cs

@@ -0,0 +1,48 @@
+using System;
+using Server.Items;
+
+namespace Server.Items
+{
+
+	public class SimpleArtifact : Artifact
+	{
+		private int m_ArtifactRarity = 0;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public override int ArtifactRarity
+		{ 
+			get{ return m_ArtifactRarity; }
+			set {m_ArtifactRarity = value; InvalidateProperties();}
+		}
+
+		[Constructable]
+		public SimpleArtifact(int itemID) : base(itemID)
+		{
+		}
+
+		public SimpleArtifact( Serial serial ) : base( serial )
+		{
+		}
+ 
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+
+			writer.Write( m_ArtifactRarity );
+
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+
+			m_ArtifactRarity = reader.ReadInt();
+
+		}
+	}
+}

Scripts/Services/XmlSpawner/XMLSpawner Support/SpawnerExporter.cs

@@ -0,0 +1,263 @@
+using System;
+using System.IO;
+using System.Xml;
+using System.Collections;
+using System.Collections.Generic;
+using Server;
+using Server.Commands;
+using Server.Commands.Generic;
+
+/*
+** Sno's distro spawner importer/exporter
+**
+** [exportspawner filename - Saves distro spawners to XML to 'Saves/Spawners/filename'
+**
+** [importspawner filename - Restores distro spawners from 'Saves/Spawners/filename'.  Note, this command does not check for
+** duplication, so if you run it more than once you will end up with multiple spawners.
+**
+** These spawns can also be imported back in as XmlSpawners by using the '[xmlimportspawners Saves/Spawners/filename' command.
+*/
+
+namespace Server.Mobiles
+{
+	public class SpawnerExporter
+	{
+	        public static void Initialize()
+		{
+			TargetCommands.Register( new ExportSpawnerCommand() );
+			CommandSystem.Register("ImportSpawners", AccessLevel.Administrator, new CommandEventHandler(ImportSpawners_OnCommand));
+		}
+		
+		public class ExportSpawnerCommand : BaseCommand
+		{
+			public ExportSpawnerCommand()
+			{
+				AccessLevel = AccessLevel.Administrator;
+				Supports = CommandSupport.Area | CommandSupport.Region | CommandSupport.Global | CommandSupport.Multi | CommandSupport.Single;
+				Commands = new string[]{ "ExportSpawner" };
+				ObjectTypes = ObjectTypes.Items;
+				Usage = "ExportSpawner <filename>";
+				Description = "Exports all Spawner objects to the specified filename.";
+				ListOptimized = true;
+			}
+			
+			public override void ExecuteList( CommandEventArgs e, ArrayList list )
+			{
+				string filename = e.GetString( 0 );
+			
+				ArrayList spawners = new ArrayList();
+			
+				for ( int i = 0; i < list.Count; ++i )
+				{
+					if ( list[i] is Spawner  )
+					{
+						Spawner spawner = (Spawner)list[i];
+						if ( spawner != null && !spawner.Deleted && spawner.Map != Map.Internal && spawner.Parent == null )
+							spawners.Add( spawner );
+					}
+				}
+				
+				AddResponse( String.Format( "{0} spawners exported to Saves/Spawners/{1}.", spawners.Count.ToString(), filename ) );
+				
+				ExportSpawners( spawners, filename );
+			}
+			
+			public override bool ValidateArgs( BaseCommandImplementor impl, CommandEventArgs e )
+			{
+				if ( e.Arguments.Length >= 1 )
+					return true;
+				
+				e.Mobile.SendMessage( "Usage: " + Usage );
+				return false;
+			}
+			
+			private void ExportSpawners( ArrayList spawners, string filename )
+			{
+				if ( spawners.Count == 0 )
+					return;
+			
+				if ( !Directory.Exists( "Saves/Spawners" ) )
+					Directory.CreateDirectory( "Saves/Spawners" );
+	
+				string filePath = Path.Combine( "Saves/Spawners", filename );
+	
+				using ( StreamWriter op = new StreamWriter( filePath ) )
+				{
+					XmlTextWriter xml = new XmlTextWriter( op );
+	
+					xml.Formatting = Formatting.Indented;
+					xml.IndentChar = '\t';
+					xml.Indentation = 1;
+	
+					xml.WriteStartDocument( true );
+	
+					xml.WriteStartElement( "spawners" );
+	
+					xml.WriteAttributeString( "count", spawners.Count.ToString() );
+	
+					foreach ( Spawner spawner in spawners )
+						ExportSpawner( spawner, xml );
+	
+					xml.WriteEndElement();
+	
+					xml.Close();
+				}
+			}
+			
+			private void ExportSpawner( Spawner spawner, XmlTextWriter xml )
+			{
+				xml.WriteStartElement( "spawner" );
+	
+				xml.WriteStartElement( "count" );
+				xml.WriteString( spawner.MaxCount.ToString() );		
+				xml.WriteEndElement();
+				
+				xml.WriteStartElement( "group" );
+				xml.WriteString( spawner.Group.ToString() );
+				xml.WriteEndElement();
+				
+				xml.WriteStartElement( "homerange" );
+				xml.WriteString( spawner.HomeRange.ToString() );
+				xml.WriteEndElement();
+
+				xml.WriteStartElement("walkingrange");
+				xml.WriteString(spawner.WalkingRange.ToString());
+				xml.WriteEndElement();
+
+				xml.WriteStartElement( "maxdelay" );
+				xml.WriteString( spawner.MaxDelay.ToString() );
+				xml.WriteEndElement();
+				
+				xml.WriteStartElement( "mindelay" );
+				xml.WriteString( spawner.MinDelay.ToString() );
+				xml.WriteEndElement();
+				
+				xml.WriteStartElement( "team" );
+				xml.WriteString( spawner.Team.ToString() );
+				xml.WriteEndElement();
+				
+				xml.WriteStartElement( "creaturesname" );
+                foreach(var kvp in spawner.SpawnObjects)
+				{
+					xml.WriteStartElement( "creaturename" );
+                    xml.WriteString(kvp.SpawnName);
+					xml.WriteEndElement();
+				}
+				xml.WriteEndElement();
+				
+				// Item properties
+				
+				xml.WriteStartElement( "name" );
+				xml.WriteString( spawner.Name );
+				xml.WriteEndElement();
+				
+				xml.WriteStartElement( "location" );
+				xml.WriteString( spawner.Location.ToString() );
+				xml.WriteEndElement();
+				
+				xml.WriteStartElement( "map" );
+				xml.WriteString( spawner.Map.ToString() );
+				xml.WriteEndElement();
+	
+				xml.WriteEndElement();
+			}
+		}
+		
+		[Usage( "ImportSpawners" )]
+        	[Description( "Recreates Spawner items from the specified file." )]
+		public static void ImportSpawners_OnCommand( CommandEventArgs e )
+		{
+			if ( e.Arguments.Length >= 1 )
+			{
+				string filename = e.GetString( 0 );
+				string filePath = Path.Combine( "Saves/Spawners", filename );
+				
+				if ( File.Exists( filePath ) )
+				{
+					XmlDocument doc = new XmlDocument();
+					doc.Load( filePath );
+
+					XmlElement root = doc["spawners"];
+
+					int successes = 0, failures = 0;
+					
+					foreach ( XmlElement spawner in root.GetElementsByTagName( "spawner" ) )
+					{
+						try
+						{
+							ImportSpawner( spawner );
+							successes++;
+						}
+						catch { failures++; }
+					}
+					
+					e.Mobile.SendMessage( "{0} spawners loaded successfully from {1}, {2} failures.", successes, filePath, failures );
+				}
+				else
+				{
+					e.Mobile.SendMessage( "File {0} does not exist.", filePath );
+				}
+			}
+			else
+			{
+				e.Mobile.SendMessage( "Usage: [ImportSpawners <filename>" );
+			}
+		}
+		
+		private static string GetText( XmlElement node, string defaultValue )
+		{
+			if ( node == null )
+				return defaultValue;
+
+			return node.InnerText;
+		}
+		
+		private static void ImportSpawner( XmlElement node )
+		{
+			int count = int.Parse( GetText( node["count"], "1" ) );
+			int homeRange = int.Parse( GetText( node["homerange"], "4" ) );
+
+			int walkingRange = int.Parse(GetText(node["walkingrange"], "-1"));
+
+			int team = int.Parse( GetText( node["team"], "0" ) );
+			
+			bool group = bool.Parse( GetText( node["group"], "False" ) );
+			TimeSpan maxDelay = TimeSpan.Parse( GetText( node["maxdelay"], "10:00" ) );
+			TimeSpan minDelay = TimeSpan.Parse( GetText( node["mindelay"], "05:00" ) );
+			List<string> creaturesName = LoadCreaturesName( node["creaturesname"] );
+		
+			string name = GetText( node["name"], "Spawner" );
+			Point3D location = Point3D.Parse( GetText( node["location"], "Error" ) );
+			Map map = Map.Parse( GetText( node["map"], "Error" ) );
+			
+			Spawner spawner = new Spawner( count, minDelay, maxDelay, team, homeRange, creaturesName );
+			if (walkingRange >= 0)
+				spawner.WalkingRange = walkingRange;
+
+			spawner.Name = name;
+			spawner.MoveToWorld( location, map );
+			if ( spawner.Map == Map.Internal )
+			{
+				spawner.Delete();
+				throw new Exception( "Spawner created on Internal map." );
+			}
+			spawner.Respawn();
+		}
+
+		private static List<string> LoadCreaturesName(XmlElement node)
+		{
+			List<string> names = new List<string>();
+
+			if ( node != null )
+			{
+				foreach ( XmlElement ele in node.GetElementsByTagName( "creaturename" ) )
+				{
+					if ( ele != null )
+						names.Add( ele.InnerText );
+				}
+			}
+			
+			return names;
+		}
+	}
+}

Scripts/Services/XmlSpawner/XMLSpawner Support/StaffCloak.cs

@@ -0,0 +1,163 @@
+using System;
+using Server.Mobiles;
+
+/*
+** Allows staff to quickly switch between player and their assigned staff levels by equipping or removing the cloak
+** Also allows instant teleportation to a specified destination when double-clicked by the staff member.
+*/
+
+namespace Server.Items
+{
+    public class StaffCloak : Cloak
+    {
+            
+        private AccessLevel m_StaffLevel;
+        private Point3D m_HomeLoc;
+        private Map m_HomeMap;
+
+        [CommandProperty( AccessLevel.Administrator )]
+        public AccessLevel StaffLevel { 
+            get 
+            { 
+                return m_StaffLevel;
+            }
+            set 
+            { 
+                m_StaffLevel = value;
+                InvalidateProperties();
+            }
+        }
+
+        [CommandProperty( AccessLevel.GameMaster )]
+        public Point3D HomeLoc { get { return m_HomeLoc;} set { m_HomeLoc = value;} }
+
+        [CommandProperty( AccessLevel.GameMaster )]
+        public Map HomeMap { get { return m_HomeMap;} set { m_HomeMap = value;} }
+
+        public override void GetProperties( ObjectPropertyList list )
+		{
+
+			base.GetProperties(list);
+
+            list.Add( 1060658, "Level\t{0}", StaffLevel ); // ~1_val~: ~2_val~
+
+		}
+
+#if(NEWPARENT)
+		public override void OnAdded(IEntity parent)
+#else
+		public override void OnAdded(object parent)
+#endif
+        {
+            base.OnAdded( parent );
+
+            // delete this if someone without the necessary access level picks it up or tries to equip it
+            if(RootParent is Mobile)
+            {
+                if (((Mobile) RootParent).AccessLevel != StaffLevel)
+                {
+                    Delete();
+                    return;
+                }
+            }
+
+            // when equipped, change access level to player
+            if ( parent is Mobile )
+            {
+                Mobile m =(Mobile) parent;
+
+                if (m.AccessLevel == StaffLevel)
+                {
+                    m.AccessLevel = AccessLevel.Player;
+                    // and make vuln
+                    m.Blessed = false;
+                }
+            }
+        }
+
+#if(NEWPARENT)
+        public override void OnRemoved( IEntity parent )
+#else
+        public override void OnRemoved( object parent )
+#endif
+        {
+            base.OnRemoved( parent );
+
+            // restore access level to the specified level
+            if ( parent is Mobile && !Deleted)
+            {
+                Mobile m = (Mobile) parent;
+                
+                // restore their assigned staff level
+                m.AccessLevel = StaffLevel;
+                // and make invuln
+                m.Blessed = true;
+            }
+        }
+        
+        public override void OnDoubleClick( Mobile from )
+        {
+            if(from == null) return;
+
+            if(HomeMap != Map.Internal && HomeMap != null && from.AccessLevel == StaffLevel)
+            {
+                // teleport them to the specific location
+                from.MoveToWorld(HomeLoc, HomeMap);
+            }
+        }
+
+        [Constructable]
+        public StaffCloak() : base()
+        {
+
+            StaffLevel= AccessLevel.Administrator;  // assign admin staff level by default
+            LootType = LootType.Blessed;
+            Name = "Staff Cloak";
+            Weight = 0;
+
+        } 
+
+        public StaffCloak( Serial serial ) : base( serial )
+        {
+        }
+
+        public override void Serialize( GenericWriter writer )
+        { 
+            base.Serialize( writer );
+
+            // version
+            writer.Write( (int) 0 );
+            // version 0
+            writer.Write( (int) m_StaffLevel );
+            writer.Write( m_HomeLoc );
+            string mapname = null;
+            if(m_HomeMap != null)
+            {
+                mapname = m_HomeMap.Name;
+            }
+            writer.Write( mapname );
+        } 
+
+        public override void Deserialize(GenericReader reader) 
+        { 
+                base.Deserialize( reader );
+
+                int version = reader.ReadInt();
+                
+                switch(version)
+                {
+                case 0:
+                    m_StaffLevel = (AccessLevel)reader.ReadInt();
+                	m_HomeLoc = reader.ReadPoint3D();
+                	string mapname = reader.ReadString();
+
+                	try{
+                	m_HomeMap = Map.Parse(mapname);
+                	} catch{}
+
+                	break;
+                }
+        
+        }
+    }
+}