DebugConsole.cs

Go to the documentation of this file.

#pragma warning disable 0649
using UnityEngine;
using UnityEngine.UI;
using System.Text;
using System.Collections;
using System.Collections.Generic;

namespace HKI.Core.Debuging
{
    public class DebugConsole : MonoBehaviour
    {
        // Class
        public class Command
        {
            // Delegate
            public delegate void ConsoleCommandFunction(string[] parameters);

            // Public variables
            public const string NoHelpString = "(no description)";

            // Private variables
            ConsoleCommandFunction callback = null;
            string name = null;
            string paramsExample = null;
            string help = null;

            // Getter
            public ConsoleCommandFunction Callback { get { return callback; } }
            public string Name { get { return name; } }
            public string ParamsExample { get { return paramsExample; } }
            public string Help { get { return help; } }

            // Constructor
            public Command(string name, ConsoleCommandFunction callback, string help, string paramsExample)
            {
                this.callback = callback;
                this.name = name;
                this.paramsExample = paramsExample;
                this.help = help;
            }
        }

        // Public variables
        public static DebugConsole Instance { get; private set; }

        [SerializeField] DebugSystem DebugSystem = null;

        [SerializeField] Scrollbar Scrollbar = null;
        [SerializeField] InputField CommandInputField = null;
        
        [SerializeField] Color EchoColor = new Color(0.2f, 0.2f, 0.2f, 1.0f);
        [SerializeField] Color LogColor = Color.white;
        [SerializeField] Color WarningColor = new Color(1.0f, 0.5f, 0.0f, 1.0f);
        [SerializeField] Color ErrorColor = Color.red;
        [SerializeField] Color CommandColor = Color.cyan;
        [SerializeField] Color InvalidCommand = Color.magenta;

        [SerializeField] Text[] Texts;

        // Private variables
        Queue<Text> textStack = new Queue<Text>();

        const string sizeStartString = "<size=10>";
        const string sizeEndString = "</size>";

        Dictionary<string, Command> commands = new Dictionary<string, Command>();

        string[] seperators = new string[] { "| ", " | ", "|" };

        // Awake function
        void Awake()
        {
            if(Instance == null)
                Instance = this;
            else
                return;

            if(Texts != null)
            {
                for(int i = 0; i < Texts.Length; i++)
                {
                    Texts[i].gameObject.SetActive(false);
                    textStack.Enqueue(Texts[i]);
                }                
            }

            StartCoroutine(SetScrollPosition());

            Application.logMessageReceived += OnLogReceived;

            InitConsoleCommands();
        }

        // OnDestroy
        void OnDestroy()
        {
            if(Instance == this)
                Instance = null;
            else
                return;

            Application.logMessageReceived -= OnLogReceived;
        }
        
        // Interface functions
        public void OnSubmit()
        {
            if(!string.IsNullOrEmpty(CommandInputField.text))
            {
                string command = CommandInputField.text;
                
                CommandInputField.text = "";
                ValidateAndCallCommand(command);
            }

            DebugSystem.StartCoroutine(SetScrollPosition());
        }

        public void RegisterCommand(string name, Command.ConsoleCommandFunction callback, string help = Command.NoHelpString, string paramsExample = "")
        {
            if(string.IsNullOrEmpty(name))
            {
                Debug.LogError("You are trying to register a command but this command doesn't have a name.");
                return;
            }

            if(callback == null)
            {
                Debug.LogError("You are trying to register a command (" + name + ") but this commands callback function is null.");
                return;
            }

            string nameLower = name.ToLower();

            if (!commands.ContainsKey(nameLower))
                commands.Add(nameLower, new Command(nameLower, callback, help, paramsExample));
            else
                Debug.LogError("You are trying to register a command (" + name + ") but this command already exists.");
        }

        public void DeregisterCommand(string name)
        {
            if (string.IsNullOrEmpty(name))
            {
                Debug.LogError("You are trying to deregister a command but this command doesn't have a name.");
                return;
            }

            string nameLower = name.ToLower();

            if(commands.ContainsKey(nameLower))
                commands.Remove(nameLower);
            else
                Debug.LogError("You are trying to deregister a command (" + name + ") but this command doesn't exists.");
        }

        // Helper functions
        void OnLogReceived(string logString, string stackTrace, LogType type)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine(logString);
            sb.Append(sizeStartString);
            sb.Append(stackTrace.Remove(0, stackTrace.IndexOf('\n') + 1));
            sb.Remove(sb.Length - 1, 1);
            sb.Append(sizeEndString);

            switch(type)
            {
                case LogType.Log:
                    Print(LogColor, sb.ToString());
                    break;

                case LogType.Error:
                case LogType.Exception:
                case LogType.Assert:
                    Print(ErrorColor, sb.ToString());
                    break;

                case LogType.Warning:
                    Print(WarningColor, sb.ToString());
                    break;
            }

            DebugSystem.StartCoroutine(SetScrollPosition());
        }

        void Print(Color color, string msg)
        {
            Text text = textStack.Dequeue();
            text.text = msg;
            text.color = color;
            text.transform.SetAsLastSibling();
            text.gameObject.SetActive(true);
            textStack.Enqueue(text);
        }

        void ValidateAndCallCommand(string fullCommand)
        {
            int openParenteciesIndex = fullCommand.IndexOf('(');
            if(openParenteciesIndex >= 0 && fullCommand[fullCommand.Length - 1] != ')')
            {
                Print(InvalidCommand, fullCommand);
                return;
            }

            string command = openParenteciesIndex >= 0 ? fullCommand.Remove(openParenteciesIndex).ToLower() : fullCommand.ToLower();

            if(string.IsNullOrEmpty(command) || !commands.ContainsKey(command))
            {
                Print(InvalidCommand, fullCommand);
                return;
            }

            string[] parameters = openParenteciesIndex >= 0 ? fullCommand.Substring(openParenteciesIndex + 1, fullCommand.Length - openParenteciesIndex - 2).Split(seperators, System.StringSplitOptions.None) : null;

            Print(CommandColor, fullCommand);

            commands[command].Callback(parameters);
        }

        void InitConsoleCommands()
        {
            RegisterCommand("Help", Help, "Displays all commands and help information for console commands when they are available.");
            RegisterCommand("Clear", Clear, "Clears the console history.");
            RegisterCommand("Cls", Clear, "Clears the console history (alias for Clear)");
            RegisterCommand("Echo", Echo, "Writes <string> message to the console", "<string> message");
            RegisterCommand("Print", Echo, "Writes <string> message to the console (alias for echo)", "<string> message");
            RegisterCommand("QuitGame", Quit, "Quit the game.");
            RegisterCommand("Quit Game", Quit, "Quit the game.");

            RegisterCommand("Log", Debug.Log, "Log a msg to the console.", "string");
        }

        void Clear(string[] parameters)
        {
            if (Texts != null)
            {
                for (int i = 0; i < Texts.Length; i++)
                    Texts[i].gameObject.SetActive(false);
            }
        }

        void Help(string[] parameters)
        {
            StringBuilder sb = new StringBuilder("<color=#ffffff>Commands:</color>");
            foreach(Command cmd in commands.Values)
            {
                sb.Append("\n<color=#ffffff>> ");
                sb.Append(cmd.Name);
                sb.Append("(");
                sb.Append(cmd.ParamsExample);
                sb.Append(")</color>\n     ");
                sb.Append(cmd.Help);
            }

            Print(EchoColor, sb.ToString());
        }

        void Echo(string[] parameters)
        {
            if(parameters != null && parameters.Length == 1)
                Print(EchoColor, "Echo: " + parameters[0]);
        }

        void Quit(string[] parameters)
        {
            Application.Quit();
        }

        IEnumerator SetScrollPosition()
        {
            yield return null;

            if (Scrollbar != null)
                Scrollbar.value = 0.0f;
        }
    }
}