Esempio n. 1
0
 public static void Echo(Context context, params object[] message)
 {
     foreach (var msg in message)
     {
         context.Notify(msg);
     }
 }
Esempio n. 2
0
 public static void Cat(Context context, string category)
 {
     var cat = category.ToLower().Trim();
     if (cat == "")
     {
         context.Notify("Current category: " + context.Category);
         return;
     }
     context.Category = cat == "$" ? "" : cat;
 }
Esempio n. 3
0
        public static void Decrement(Context context, string cvName)
        {
            Convar convar;
            if (!context.RequestConvar(cvName, out convar)) return;

            var o = convar.Value;
            if (!Util.Decrement(ref o))
            {
                context.Notify("Convar '" + cvName + "' is not a numeric type.");
                return;
            }
            convar.Value = o;
        }
Esempio n. 4
0
 public static void Exec(Context context, params string[] files)
 {
     foreach (var path in files)
     {
         try
         {
             using (var reader = new StreamReader(path))
             {
                 while (!reader.EndOfStream)
                 {
                     // ReSharper disable once PossibleNullReferenceException
                     // ReadLine() should never be null since the loop breaks at EOF
                     Devcom.Submit(context, reader.ReadLine().Trim());
                 }
             }
         }
         catch (Exception ex)
         {
             context.NotifyFormat("Failed to load {0}: '{1}'", path, ex.Message);
         }
     }
 }
Esempio n. 5
0
        internal CallArgs TranslateArgs(Context context, string[] args)
        {
            var currentContextType = context.GetType();

            // Check context type compatability
            if ((!currentContextType.IsSubclassOf(_contextType) && currentContextType != _contextType) || !ContextFilter.Test(currentContextType, Filter))
            {
                throw new ArgumentException(String.Concat("Incompatible context type: '", currentContextType.Name, "'"));
            }

            int argc = args.Length;
            int paramc = _paramList.Length - 1;
            if ((_hasParamsArgument && argc < paramc) || (argc < paramc - _numOptionalParams) || (!_hasParamsArgument && argc > paramc))
            {
                throw new ArgumentException("Parameter count mismatch.");
            }

            var boxed = Enumerable.Repeat(Type.Missing, paramc).ToArray();

            // Convert parameters to the proper types
            for (int i = 0; i < paramc; i++)
            {
                boxed[i] = Util.ChangeType(args[i], _paramList[(i >= paramc ? paramc - 1 : i) + 1].ParameterType);
            }

            var argsFormatted = new List<object> { context };

            // Add all arguments except for any marked as 'params'
            argsFormatted.AddRange(boxed.Take(_hasParamsArgument ? paramc - 1 : paramc));

            // Insert params argument as an array (it needs to be represented as a single object)
            if (_hasParamsArgument)
            {
                argsFormatted.Add(args.Where((o, i) => i >= paramc - 1).ToArray());
            }

            return new CallArgs(_method, argsFormatted);
        }
Esempio n. 6
0
        internal bool Run(Context context, params string[] args)
        {
            var currentContextType = context.GetType();

            // Check context type compatability
            if ((!currentContextType.IsSubclassOf(_contextType) && currentContextType != _contextType) || !ContextFilter.Test(currentContextType, Filter))
            {
                context.PostCommandNotFound(QualifiedName);
                return false;
            }

            int argc = args.Length;
            int paramc = _paramList.Length - 1;
            try
            {
                if ((_hasParamsArgument && argc < paramc) || (argc < paramc - _numOptionalParams) || (!_hasParamsArgument && argc > paramc))
                {
                    context.Notify("Parameter count mismatch.");
                    return false;
                }

                var boxed = Enumerable.Repeat(Type.Missing, paramc).ToArray();

                // Convert parameters to the proper types
                for (int i = 0; i < paramc; i++)
                {
                    boxed[i] = Util.ChangeType(args[i], _paramList[(i >= paramc ? paramc - 1 : i) + 1].ParameterType);
                }

                var argsFormatted = new List<object> { context };

                // Add all arguments except for any marked as 'params'
                argsFormatted.AddRange(boxed.Take(_hasParamsArgument ? paramc - 1 : paramc));

                // Insert params argument as an array (it needs to be represented as a single object)
                if (_hasParamsArgument)
                {
                    argsFormatted.Add(args.Where((o, i) => i >= paramc - 1).ToArray());
                }

                // Call the method with our parameters
                _method.Invoke(null, argsFormatted.ToArray());
            }
            catch(Exception ex)
            {
                if (SystemConvars.Throws)
                {
                    throw;
                }
                context.Notify("Error: " + ex);
                return false;
            }
            return true;
        }
Esempio n. 7
0
 public static void Help(Context context, string command)
 {
     command = command.ToLower();
     Command cmd;
     if (!Devcom.Commands.TryGetValue(Util.Qualify(context.Category, command), out cmd))
     {
         context.Notify("Command not found: '" + command + "'");
         return;
     }
     var sb = new StringBuilder();
     sb.Append(cmd.QualifiedName).Append(": ").Append(cmd.Description).AppendLine();
     sb.Append("Syntax: ").Append(cmd.QualifiedName).Append(" ").Append(cmd.ParamHelpString);
     context.Notify(sb.ToString());
 }
Esempio n. 8
0
 public static void LoadConfig(Context context)
 {
     ConvarConfig.LoadConvars();
 }
Esempio n. 9
0
        /// <summary>
        /// Translates a command string into a reusable Call object.
        /// </summary>
        /// <param name="context">The context to attach to the call.</param>
        /// <param name="command">The command string to translate.</param>
        /// <returns></returns>
        public static Call TranslateCommand(Context context, string command)
        {
            if (!_loaded) throw new InvalidOperationException("Cannot translate command calls without loading Devcom.");

            context = context ?? Context.Default;

            if (context == null) throw new ArgumentNullException("context");
            if (String.IsNullOrEmpty(command))
            {
                return Call.None;
            }

            // Cut off spaces from both ends
            command = command.Trim();

            var calls = new List<CallArgs>();

            foreach (var cmdstr in command.Split(new[] { '|', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
                    .Select(s => s.Trim()))
            {
                // Split up the line into arguments
                var parts = cmdstr.ParseParams().ToArray();
                if (!parts.Any()) continue;

                // The first index will be the command name
                var first = parts.First().ToLower();

                // Check if it's a root marker
                if (first == "$")
                {
                    context.Category = "";
                    continue;
                }

                // Make sure the command exists
                Command cmd;
                if (!Commands.TryGetValue(first, out cmd))
                {
                    throw new ArgumentException(String.Concat("Command not found: '", first, "'"));
                }

                if (parts.Length > 1)
                {
                    for (int i = 1; i < parts.Length; i++)
                    {
                        parts[i] = Regex.Replace(parts[i], @":(?<name>\S+):",
                            m => Util.GetConvarValue(m.Groups["name"].Value, context.Category),
                            RegexOptions.ExplicitCapture);
                    }
                }

                calls.Add(cmd.TranslateArgs(context, parts));
            }

            return new Call(calls.ToArray());
        }
Esempio n. 10
0
        public static void Toggle(Context context, string cvName)
        {
            Convar convar;
            if (!context.RequestConvar(cvName, out convar)) return;

            if (convar.Value.GetType() != typeof(bool))
            {
                context.Notify("Convar '" + cvName + "' is not a boolean type.");
                return;
            }
            convar.Value = !((bool)convar.Value);
            context.NotifyFormat("{0} = {1}", convar.QualifiedName, convar.Value);
        }
Esempio n. 11
0
 public static void SetConVar(Context context, string cvName, string value)
 {
     Convar convar;
     if (!context.RequestConvar(cvName, out convar)) return;
     convar.Value = value;
 }
Esempio n. 12
0
 public static void SaveConfig(Context context)
 {
     ConvarConfig.SaveConvars();
 }
Esempio n. 13
0
 public static void Root(Context context)
 {
     context.Category = "";
 }
Esempio n. 14
0
 public static void ResetConvar(Context context, string cvName)
 {
     Convar convar;
     if (!context.RequestConvar(cvName, out convar)) return;
     convar.Value = convar.DefaultValue;
 }
Esempio n. 15
0
        /// <summary>
        /// Executes a command string under the specified context.
        /// </summary>
        /// <param name="context">The context under which to execute the command.</param>
        /// <param name="command">The command to execute.</param>
        public static void Submit(Context context, string command)
        {
            if (!_loaded) return;

            // Set the context to default if null was passed
            context = context ?? Context.Default;

            if (SystemConvars.EchoInput)
            {
                context.Notify("> " + command);
            }

            // Don't interpret empty commands
            if (String.IsNullOrEmpty(command)) return;

            // Cut off spaces from both ends
            command = command.Trim();

            foreach (var cmdstr in command.Split(new[] { '|', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
                    .Select(s => s.Trim()))
            {
                // Split up the line into arguments
                var parts = cmdstr.ParseParams().ToArray();
                if (!parts.Any()) continue;

                // The first index will be the command name
                var first = parts.First().ToLower();
                
                // Check if it's a root marker
                if (first == "$")
                {
                    context.Category = "";
                    continue;
                }

                // Check for root marker at the start of command name
                bool root = false;
                if (first.StartsWith("$"))
                {
                    root = true;
                    first = first.Substring(1);
                }

                // Get the fully-qualified name, taking into account root markers and current category
                string qname = root ? first : (context.Category.Length > 0 ? context.Category + "." : "") + first;

                // Make sure the command exists
                Command cmd;
                if (!Commands.TryGetValue(qname, out cmd))
                {
                    context.PostCommandNotFound(qname);
                    continue;
                }

                if (parts.Length > 1)
                {
                    for (int i = 1; i < parts.Length; i++)
                    {
                        parts[i] = Regex.Replace(parts[i], @":(?<name>\S+):",
                            m => Util.GetConvarValue(m.Groups["name"].Value, context.Category),
                            RegexOptions.ExplicitCapture);
                    }
                }

                // Run the command
                cmd.Run(context, parts.Where((s, i) => i > 0).ToArray());
            }
        }
Esempio n. 16
0
 /// <summary>
 /// Executes a command string asynchronously under the specified context.
 /// </summary>
 /// <param name="context">The context under which to execute the command.</param>
 /// <param name="command">The command to execute.</param>
 public static async void SendCommandAsync(Context context, string command)
 {
     await Task.Run(() => Submit(context, command));
 }
Esempio n. 17
0
 public static void Date(Context context)
 {
     context.Notify(DateTime.Now.ToString("R"));
 }
Esempio n. 18
0
 public static void Sub(Context context, double a, double b, string cvOut)
 {
     Convar o;
     if (!context.RequestConvar(cvOut, out o)) return;
     o.Value = a - b;
 }
Esempio n. 19
0
 public static void ListCommands(Context context)
 {
     var contextType = context.GetType();
     context.Notify(
         Devcom.Commands.Where(cmd => ContextFilter.Test(contextType, cmd.Value.Filter) &&
             (cmd.Value.ContextType == contextType || contextType.IsSubclassOf(cmd.Value.ContextType)))
         .Select(cmd => cmd.Key)
         .Aggregate((accum, name) => accum + "\n" + name));
 }