Overwrite

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

Server/Commands.cs

@@ -0,0 +1,288 @@
+#region References
+using System;
+using System.Collections.Generic;
+
+using Server.Network;
+#endregion
+
+namespace Server.Commands
+{
+	public delegate void CommandEventHandler(CommandEventArgs e);
+
+	public class CommandEventArgs : EventArgs
+	{
+		private readonly Mobile m_Mobile;
+		private readonly string m_Command;
+		private readonly string m_ArgString;
+		private readonly string[] m_Arguments;
+
+		public Mobile Mobile { get { return m_Mobile; } }
+
+		public string Command { get { return m_Command; } }
+
+		public string ArgString { get { return m_ArgString; } }
+
+		public string[] Arguments { get { return m_Arguments; } }
+
+		public int Length { get { return m_Arguments.Length; } }
+
+		public string GetString(int index)
+		{
+			if (index < 0 || index >= m_Arguments.Length)
+			{
+				return "";
+			}
+
+			return m_Arguments[index];
+		}
+
+		public int GetInt32(int index)
+		{
+			if (index < 0 || index >= m_Arguments.Length)
+			{
+				return 0;
+			}
+
+			return Utility.ToInt32(m_Arguments[index]);
+		}
+
+		public bool GetBoolean(int index)
+		{
+			if (index < 0 || index >= m_Arguments.Length)
+			{
+				return false;
+			}
+
+			return Utility.ToBoolean(m_Arguments[index]);
+		}
+
+		public double GetDouble(int index)
+		{
+			if (index < 0 || index >= m_Arguments.Length)
+			{
+				return 0.0;
+			}
+
+			return Utility.ToDouble(m_Arguments[index]);
+		}
+
+		public TimeSpan GetTimeSpan(int index)
+		{
+			if (index < 0 || index >= m_Arguments.Length)
+			{
+				return TimeSpan.Zero;
+			}
+
+			return Utility.ToTimeSpan(m_Arguments[index]);
+		}
+
+		public CommandEventArgs(Mobile mobile, string command, string argString, string[] arguments)
+		{
+			m_Mobile = mobile;
+			m_Command = command;
+			m_ArgString = argString;
+			m_Arguments = arguments;
+		}
+	}
+
+	public class CommandEntry : IComparable
+	{
+		private readonly string m_Command;
+		private readonly CommandEventHandler m_Handler;
+		private readonly AccessLevel m_AccessLevel;
+
+		public string Command { get { return m_Command; } }
+
+		public CommandEventHandler Handler { get { return m_Handler; } }
+
+		public AccessLevel AccessLevel { get { return m_AccessLevel; } }
+
+		public CommandEntry(string command, CommandEventHandler handler, AccessLevel accessLevel)
+		{
+			m_Command = command;
+			m_Handler = handler;
+			m_AccessLevel = accessLevel;
+		}
+
+		public int CompareTo(object obj)
+		{
+			if (obj == this)
+			{
+				return 0;
+			}
+			else if (obj == null)
+			{
+				return 1;
+			}
+
+			CommandEntry e = obj as CommandEntry;
+
+			if (e == null)
+			{
+				throw new ArgumentException();
+			}
+
+			return m_Command.CompareTo(e.m_Command);
+		}
+	}
+
+	public static class CommandSystem
+	{
+		private static string m_Prefix = "[";
+
+		public static string Prefix { get { return m_Prefix; } set { m_Prefix = value; } }
+
+		public static string[] Split(string value)
+		{
+			var array = value.ToCharArray();
+			var list = new List<string>();
+
+			int start = 0, end = 0;
+
+			while (start < array.Length)
+			{
+				char c = array[start];
+
+				if (c == '"')
+				{
+					++start;
+					end = start;
+
+					while (end < array.Length)
+					{
+						if (array[end] != '"' || array[end - 1] == '\\')
+						{
+							++end;
+						}
+						else
+						{
+							break;
+						}
+					}
+
+					list.Add(value.Substring(start, end - start));
+
+					start = end + 2;
+				}
+				else if (c != ' ')
+				{
+					end = start;
+
+					while (end < array.Length)
+					{
+						if (array[end] != ' ')
+						{
+							++end;
+						}
+						else
+						{
+							break;
+						}
+					}
+
+					list.Add(value.Substring(start, end - start));
+
+					start = end + 1;
+				}
+				else
+				{
+					++start;
+				}
+			}
+
+			return list.ToArray();
+		}
+
+		private static readonly Dictionary<string, CommandEntry> m_Entries;
+
+		public static Dictionary<string, CommandEntry> Entries { get { return m_Entries; } }
+
+		static CommandSystem()
+		{
+			m_Entries = new Dictionary<string, CommandEntry>(StringComparer.OrdinalIgnoreCase);
+		}
+
+		public static void Register(string command, AccessLevel access, CommandEventHandler handler)
+		{
+			m_Entries[command] = new CommandEntry(command, handler, access);
+		}
+
+		private static AccessLevel m_BadCommandIngoreLevel = AccessLevel.Player;
+
+		public static AccessLevel BadCommandIgnoreLevel { get { return m_BadCommandIngoreLevel; } set { m_BadCommandIngoreLevel = value; } }
+
+		public static bool Handle(Mobile from, string text)
+		{
+			return Handle(from, text, MessageType.Regular);
+		}
+
+		public static bool Handle(Mobile from, string text, MessageType type)
+		{
+			if (text.StartsWith(m_Prefix) || type == MessageType.Command)
+			{
+				if (type != MessageType.Command)
+				{
+					text = text.Substring(m_Prefix.Length);
+				}
+
+				int indexOf = text.IndexOf(' ');
+
+				string command;
+				string[] args;
+				string argString;
+
+				if (indexOf >= 0)
+				{
+					argString = text.Substring(indexOf + 1);
+
+					command = text.Substring(0, indexOf);
+					args = Split(argString);
+				}
+				else
+				{
+					argString = "";
+					command = text.ToLower();
+					args = new string[0];
+				}
+
+				CommandEntry entry = null;
+				m_Entries.TryGetValue(command, out entry);
+
+				if (entry != null)
+				{
+					if (from.AccessLevel >= entry.AccessLevel)
+					{
+						if (entry.Handler != null)
+						{
+							CommandEventArgs e = new CommandEventArgs(from, command, argString, args);
+							entry.Handler(e);
+							EventSink.InvokeCommand(e);
+						}
+					}
+					else
+					{
+						if (from.AccessLevel <= m_BadCommandIngoreLevel)
+						{
+							return false;
+						}
+
+						from.SendMessage("You do not have access to that command.");
+					}
+				}
+				else
+				{
+					if (from.AccessLevel <= m_BadCommandIngoreLevel)
+					{
+						return false;
+					}
+
+					from.SendMessage("That is not a valid command.");
+				}
+
+				return true;
+			}
+
+			return false;
+		}
+	}
+}