Пример #1
0
        /// <summary>
        /// <para>Constructor de <see cref="MDevMetodos"/>.</para>
        /// </summary>
        public MDevMetodos()        // Constructor de MDevMetodos
        {
            // Inicializar los metodos y obtener todos los elementos monobehaviour de la escena
            Metodos = new List <MethodInfo>();
            MonoBehaviour[] escenaActiva = GameObject.FindObjectsOfType <MonoBehaviour>();

            // Recorrer cada elemento monobehaviour de la escena
            foreach (MonoBehaviour mono in escenaActiva)
            {
                Type monoType = mono.GetType();

                // Recuperar los campos de la instancia mono
                MethodInfo[] metodosObtenidos = monoType.GetMethods(BindingFlags.Instance | BindingFlags.Public);

                // Busca todos los campos y encontrar los atributos
                for (int i = 0; i < metodosObtenidos.Length; i++)
                {
                    MDevAttribute comandos = Attribute.GetCustomAttribute(metodosObtenidos[i], typeof(MDevAttribute)) as MDevAttribute;

                    // Si detectamos algun atributo, agregar datos.
                    if (comandos != null)
                    {
                        nombresMetodos.Add(comandos.nombreComando);
                        Metodos.Add(metodosObtenidos[i]);
                    }
                }
            }
        }
Пример #2
0
        public string Help()
        {
            string help_string = "Lista de comandos disponibles:";

            foreach (var met in MDev.instance.mdevMetodos.Metodos)
            {
                foreach (var atri in met.GetCustomAttributes(true))
                {
                    if (atri is MDevAttribute)
                    {
                        MDevAttribute com = (MDevAttribute)atri;
                        help_string += "\n      " + com.nombreComando + " --> " + com.descripcionComando;
                    }
                }
            }
            return(help_string);
        }
Пример #3
0
        /// <summary>
        /// <para>Ejecuta un comando.</para>
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        private string EjecutarComando(string input)        // Ejecuta un comando
        {
            // Preparar la ejecucion
            AutoCompletar.Clear();
            bool          registrado       = false;
            string        resultado        = null;
            string        parentesisValido = Regex.Match(input, @"\(([^)]*)\)").Groups[1].Value;
            List <string> args             = new List <string>();
            string        comando;

            // Reemplazar con el limitador
            if (!string.IsNullOrEmpty(parentesisValido))
            {
                args    = parentesisValido.Split(new char[] { ',' }).ToList();
                comando = input.Replace(parentesisValido, "").Replace("(", "").Replace(")", "").Replace(";", "");
            }
            else
            {
                comando = input.Replace("(", "").Replace(")", "").Replace(";", "");
            }

            foreach (var met in mdevMetodos.Metodos)
            {
                // Devuelve los 3 atributos.
                foreach (object atri in met.GetCustomAttributes(true))
                {
                    if (atri is MDevAttribute)
                    {
                        MDevAttribute com = (MDevAttribute)atri;
                        if (com.nombreComando == comando)
                        {
                            if (registrado)
                            {
                                Debug.LogError("Multiples comandos se definen con: " + comando);
                            }

                            Type            type       = (met.DeclaringType);
                            ParameterInfo[] parametros = met.GetParameters();
                            List <object>   argList    = new List <object>();

                            // Argumentos de lanzamiento si hay alguno
                            if (args.Count != 0)
                            {
                                if (parametros.Length != args.Count)
                                {
                                    resultado = string.Format("El comando {0} necesita {1} parametros, solo paso {2}", comando, parametros.Length, args.Count);
                                    Debug.Log(resultado);
                                    return(resultado);
                                }
                                else
                                {
                                    // Lanzar argumentos de string para ingresar tipos de objetos
                                    for (int i = 0; i < parametros.Length; i++)
                                    {
                                        try
                                        {
                                            var a = Convert.ChangeType(args[i], parametros[i].ParameterType);
                                            argList.Add(a);
                                        }
                                        catch
                                        {
                                            resultado = string.Format("No se pudo convertir {0} al tipo {1}", args[i], parametros[i].ParameterType);
                                            Debug.LogError(resultado);
                                            return(resultado);
                                        }
                                    }
                                }
                            }
                            if (type.IsSubclassOf(typeof(UnityEngine.Object)))
                            {
                                var instance_classes = GameObject.FindObjectsOfType(type);
                                if (instance_classes != null)
                                {
                                    foreach (var instance_class in instance_classes)
                                    {
                                        resultado = (string)met.Invoke(instance_class, argList.ToArray());
                                    }
                                }
                            }
                            else
                            {
                                var instance_class = Activator.CreateInstance(type);
                                resultado = (string)met.Invoke(instance_class, argList.ToArray());
                            }
                            registrado = true;
                            break;
                        }
                    }
                }
            }

            // Devolver resultado
            if (!string.IsNullOrEmpty(resultado))
            {
                return(resultado);
            }

            // Volver si esta registrado
            if (registrado)
            {
                return(null);
            }

            // Volver un error
            return("Comando no encontrado! - Escribe \"help\" para la lista de comandos disponibles!");
        }