Beispiel #1
0
 /// <summary>Executes the command.</summary>
 public void Execute(params object[] parameters)
 {
     try
     {
         Method.Invoke(null, parameters);
     }
     catch
     {
         AdvancedConsole.Warn(AdvancedConsole.WarningType.WrongArguments);
     }
 }
Beispiel #2
0
        /// <summary>
        /// Parses the message to a command and executes it.
        /// If the message by arguments matches several commands, the one that was added earlier is called.
        /// </summary>
        public static void Execute(string message)
        {
            List <string> words            = new List <string>();
            List <string> matchingPrefixes = new List <string>();

            string        commandPrefix;
            string        commandName;
            List <object> arguments = new List <object>();

            List <Command> matchingCommands;

            #region Finding a prefix
            foreach (string prefix in Prefixes)
            {
                if (message.IndexOf(prefix) == 0)
                {
                    matchingPrefixes.Add(prefix);
                }
            }

            if (matchingPrefixes.Count == 0)
            {
                commandPrefix = String.Empty;
            }
            else
            {
                commandPrefix = matchingPrefixes.OrderByDescending(s => s.Length).First();
            }
            #endregion

            #region Finding matching commands and arguments
            message = message.Substring(commandPrefix.Length);

            words.AddRange(Regex.Split(message, " (?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)").Select(s => s.Replace("\"", "")));
            words.RemoveAll(i => i == String.Empty);

            if (words.Count == 0)
            {
                AdvancedConsole.Warn(AdvancedConsole.WarningType.WrongCommand);
                return;
            }

            commandName = words[0];
            words.Remove(commandName);
            arguments.AddRange(words.Select(s => s));

            StringScanner prefixScanner = new StringScanner(commandPrefix, StringScanner.TargetOfScanner.Prefix);
            StringScanner nameScanner   = new StringScanner(commandName, StringScanner.TargetOfScanner.Name);

            if (arguments.Count > 0)
            {
                SimpleScanner containsParametersScanner = new SimpleScanner(true, SimpleScanner.TargetOfScanner.ContainsParameters);
                matchingCommands = Find(prefixScanner, nameScanner, containsParametersScanner);
                matchingCommands.Reverse();
            }
            else
            {
                matchingCommands = Find(prefixScanner, nameScanner);
            }

            if (matchingCommands.Count == 0)
            {
                AdvancedConsole.Warn(AdvancedConsole.WarningType.WrongCommand);
                return;
            }
            #endregion

            #region Executing the most matching command
            foreach (Command command in matchingCommands)
            {
                if (!command.ContainsParameters)
                {
                    command.Execute();
                    return;
                }
                else
                {
                    ParameterInfo[] parametersInfo = command.Method.GetParameters();

                    // TODO: Parse for commands with the last parameter is an array

                    try
                    {
                        for (int i = 0; i < parametersInfo.Length; i++)
                        {
                            Type type = parametersInfo[i].ParameterType;
                            if (i < arguments.Count)
                            {
                                arguments[i] = Convert.ChangeType(arguments[i], type);
                            }
                            else
                            {
                                if (parametersInfo[i].HasDefaultValue)
                                {
                                    arguments.Add(parametersInfo[i].DefaultValue);
                                }
                                else
                                {
                                    throw new ArgumentException();
                                }
                            }
                        }
                    }
                    catch
                    {
                        if (command == matchingCommands.Last())
                        {
                            AdvancedConsole.Warn(AdvancedConsole.WarningType.WrongArguments);
                        }
                        continue;
                    }

                    command.Execute(arguments.ToArray());
                    return;
                }
            }
            #endregion
        }