Console | C# Online Compiler

Console by AleDeveloper

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;

public class Program
{
	public static void Main()
	{
		//msg:I love you so much|name:Ale||txb set &name;, &msg; ;; txb show ;; m expr p1 eLove
		while (true)
		{
			var a = new CommandInput(Console.ReadLine());
			Console.WriteLine(a + "\n" + a.error);
			foreach(var cmd in a.commands)
			{
				cmd.Run();
			}
		}
	}
}

public class CommandInput
{
	public List<Command> commands = [];
	public Dictionary<string, string> variables = [];
	public bool doPersist;
	public string error = null;
	public override string ToString()
	{
		return $"{{doPersists:\"{doPersist}\", commands:[{string.Join(",", commands)}], variables:[{string.Join(",", variables.Keys)}]}}";
	}

	//a:15||u say $a $a
	public CommandInput(string input)
	{
		if(string.IsNullOrWhiteSpace(input)) return;
		
		this.doPersist = input[0] == '#';
		if(doPersist) input = input.Remove(0,1);
		
		bool hasVariablesSection = input.Contains("||");
		string commandsSection = null;
		if (hasVariablesSection)
		{
			string variablesSection = null;
			try
			{
				variablesSection = input.Split(new[] { "||" }, StringSplitOptions.RemoveEmptyEntries)[0];
			}
			catch
			{
				error = "Missing variable declarations before the || operator";
				return;
			}

			string[] variableDefinitions = variablesSection.Split('|', StringSplitOptions.RemoveEmptyEntries);
			foreach (var varDefinition in variableDefinitions)
			{
				string[] varDefinitionTerms = varDefinition.Split(':', StringSplitOptions.RemoveEmptyEntries);
				string key = null;
				string value = null;
				try
				{
					key = varDefinitionTerms[0];
				}
				catch
				{
					error = "Missing key";
					return;
				}

				try
				{
					value = varDefinitionTerms[1];
				}
				catch
				{
					error = "Missing value";
					return;
				}

				variables.Add(key, value);
			}

			try
			{
				commandsSection = input.Split(new[] { "||" }, StringSplitOptions.RemoveEmptyEntries)[1];
			}
			catch
			{
				error = "Missing command(s) after variable declaration section";
				return;
			}
		}
		else
		{
			commandsSection = input;
		}

		string[] commands = commandsSection.Split(new[] { ";;" }, StringSplitOptions.RemoveEmptyEntries);
		for(int i = 0; i < commands.Length; i++)
		{
			commands[i] = commands[i].Trim();
		}
		foreach (var _command in commands)
		{
			string command = _command;
			if(string.IsNullOrWhiteSpace(command)) continue;
			
			bool doForce;
			if (command.Length >= 2) doForce = command.Substring(0,2).Contains('!');
			else doForce = command.Substring(0,1).Contains('!');
			if(doForce) command = StringUtils.ReplaceFirst(command,"!","");
			
			Command commandObject = new Command(command, variables,doForce);
			if(commandObject.command == "")
			{
				Console.WriteLine($"ERROR: Cannot find command '{command}'");
				continue;
			}
			this.commands.Add(commandObject);
		}
	}
}

public class Command
{
	public string command = "";
	public string[] arguments = [];
	public Dictionary<string, string> variables = [];
	public bool doForce;
	public CommandInfo commandInfo = null;
	
	public void Run()
	{
		commandInfo.behaviour?.Invoke(null,new[]{this});
	}
	
	public Command(string input, Dictionary<string, string> variables, bool doForce = false)
	{
		this.variables = variables;
		this.doForce = doForce;
		foreach (var cmdInfo in Commands.commands)
		{
			if (cmdInfo.IsValid(input))
			{
				command = cmdInfo.command;
				arguments = input.Remove(0, command.Length).Trim().Split(' ');
				break;
			}
		}
		
		for(int i = 0; i < arguments.Length; i++)
		{
			string arg = arguments[i];
			foreach(var variable in variables)
			{
				arg = arg.Replace($"&{variable.Key};",variable.Value);	
			}
			arguments[i] = arg;
		}
		
		foreach(var cmdInfo in Commands.commands)
		{
			if(cmdInfo.command == command && cmdInfo.IsValid(input))
			{
				this.commandInfo = cmdInfo;
				break;	
			}
		}
	}

	public override string ToString()
	{
		return $"{{doForce:{doForce},command:\"{command}\",arguments:[{string.Join(",", arguments)}]}}";
	}
}

public class CommandInfo
{
	public string command;
	public bool isMultiargument;
	public string[] arguments;
	public string help;
	public MethodInfo behaviour = null;
	
	public bool IsValid(string input)
	{
		if (input.Trim().Length < command.Length)
			return false;
		bool doesInputStartsWithCommandName = false;
		if (arguments.Length > 0)
		{
			doesInputStartsWithCommandName = input.StartsWith(command);
		}
		else
		{
			doesInputStartsWithCommandName = input.StartsWith(command);
		}

		bool hasCorrectArguments = false;
		string[] inputArguments = input.Remove(0, command.Length).Trim().Split(' ', StringSplitOptions.RemoveEmptyEntries);
		if (isMultiargument)
		{
			hasCorrectArguments = inputArguments.Length >= arguments.Length;
		}
		else
		{
			hasCorrectArguments = arguments.Length == inputArguments.Length;
		}

		return doesInputStartsWithCommandName && hasCorrectArguments;
	}

	public CommandInfo(string command, string[] arguments, bool isMultiargument, string help, string? behaviour = null)
	{
		this.command = command;
		this.arguments = arguments;
		this.isMultiargument = isMultiargument;
		this.help = help;
		this.behaviour = typeof(ConsoleMethods).GetMethod(behaviour ?? "");
	}
}

public static class Commands
{
	public static CommandInfo[] commands =
	{
		new("u say", new[] { "message" }, true, "Sends a message to Monika"),
		
		new("m say", new[] { "message" }, true, "Makes Monika say something","MSay"),
		new("m resp", new[] { "message" }, true, "Sends a message to Monika"),
		new("m cont", new string[] { }, false, "Continues with Monika's dialogue"),
		new("m expr", new[] { "pose", "expression" }, false, "Changes Monika's pose and expression"),
		new("m expr", new[] { "fullbody" }, false, "Changes Monika's pose and expression"),
		
		new("txb show", new string[] {}, false, "Shows the textbox"),
		new("txb show", new string[] {"message"}, true, "Sets the value of the textbox and shows it"),
		new("txb hide", new string[] {}, false, "Hide the textbox"),
		new("txb set", new string[] {"message"}, true, "Sets the value of the textbox"),
		
		new("wnd cfg", new string[] {}, false, "Opens the config window"),
		new("wnd msg", new string[] {}, false, "Opens the user message window"),
		new("wnd visuals", new string[] {}, false, "Opens the visuals window"),
		new("wnd controls", new string[] {}, false, "Opens the controls window"),
		new("wnd login", new string[] {}, false, "Opens the login window"),
		new("wnd console", new string[] {}, false, "Opens the console window"),
		new("wnd starterr", new string[] {}, false, "Opens the startup error window"),
		
		new("state get", new string[] {}, false, "Gets the application state"),
		new("state set", new string[] {"state"}, false, "Sets the application state"),
		
		new("data get", new string[] {}, false, "Gets the user data"),
		new("data rm", new string[] {"key"}, false, "Removes the user data"),
		
		new("app exit -f", new string[] {}, false, "Forces the application close","AppExitF"),
		new("app exit", new string[] {"motive"}, false, "Closes the application","AppExit"),
		
		new("yes", new string[] {}, false, "Confirms the action of a command"),
		new("no", new string[] {}, false, "Denies the action of a command"),
		new("key", new string[] {}, false, "Gets a random generated key"),
		new("var", new string[] {"name", "value"}, true, "Create or sets a variable"),
		new("help", new string[] {"command"}, true, "Displays the help menu of a specific command","HelpSpecific"),
		new("help", new string[] {}, false, "Displays the help menu","Help"),
		new("exit", new string[] {}, false, "Closes the console"),
	};
}

public static class ConsoleMethods
{
	public static void Help(Command cmd)
	{
		List<CommandInfo> commands = Commands.commands.ToList();
		for(int i = 0; i < commands.Count; i++)
		{
			CommandInfo cmdInfo = commands[i];
			
			List<string> messageSegments = [];
			messageSegments.Add(cmdInfo.command);
			
			if(cmdInfo.arguments.Length > 0)
			{
				string argsSegment = "";
				int j = 0;
				foreach(var arg in cmdInfo.arguments)
				{
					if(j == cmdInfo.arguments.Length-1 && cmdInfo.isMultiargument)
					argsSegment += $"<{arg}...> ";
					else
					argsSegment += $"<{arg}> ";
					
					j++;
				}
				argsSegment = argsSegment.Trim();
				messageSegments.Add(argsSegment);
			}
			
			messageSegments.Add($"| {cmdInfo.help}");
			
			string message = string.Join(" ",messageSegments);
			Console.WriteLine(message);
		}
	}
	
	public static void HelpSpecific(Command cmd)
	{
		List<CommandInfo> commands = [];
		string search = string.Join(" ",cmd.arguments);
		foreach(var command in Commands.commands)
		{
			if(command.command.StartsWith(search))
			{
				commands.Add(command);
			}
		}
		for(int i = 0; i < commands.Count; i++)
		{
			CommandInfo cmdInfo = commands[i];
			
			List<string> messageSegments = [];
			messageSegments.Add(cmdInfo.command);
			
			if(cmdInfo.arguments.Length > 0)
			{
				string argsSegment = "";
				int j = 0;
				foreach(var arg in cmdInfo.arguments)
				{
					if(j == cmdInfo.arguments.Length-1 && cmdInfo.isMultiargument)
					argsSegment += $"<{arg}...> ";
					else
					argsSegment += $"<{arg}> ";
					
					j++;
				}
				argsSegment = argsSegment.Trim();
				messageSegments.Add(argsSegment);
			}
			
			messageSegments.Add($"| {cmdInfo.help}");
			
			string message = string.Join(" ",messageSegments);
			Console.WriteLine(message);
		}
	}
	
	public static void AppExit(Command cmd)
	{
		Environment.Exit(0);	
	}
	public static void AppExitF(Command cmd)
	{
		Environment.Exit(0);	
	}
	public static void MSay(Command cmd)
	{
		string toSay = string.Join(" ",cmd.arguments);
		Console.WriteLine($"Monika: {toSay}");	
	}
}

public static class StringUtils
{
	public static string ReplaceFirst(string str, string term, string replace)
	{
    	int position = str.IndexOf(term);
    	if (position < 0)
    	{
        	return str;
    	}
    	str = str.Substring(0, position) + replace + str.Substring(position + term.Length);
    	return str;
	}	
}

​x
 
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
​
public class Program
{
    public static void Main()
    {
        //msg:I love you so much|name:Ale||txb set &name;, &msg; ;; txb show ;; m expr p1 eLove
        while (true)
        {
            var a = new CommandInput(Console.ReadLine());
            Console.WriteLine(a + "\n" + a.error);
            foreach(var cmd in a.commands)
            {
                cmd.Run();
            }
        }
    }
}
​
public class CommandInput
{
    public List<Command> commands = [];
    public Dictionary<string, string> variables = [];
    public bool doPersist;
    public string error = null;
    public override string ToString()
    {
        return $"{{doPersists:\"{doPersist}\", commands:[{string.Join(",", commands)}], variables:[{string.Join(",", variables.Keys)}]}}";
    }
​
    //a:15||u say $a $a
    public CommandInput(string input)
    {
        if(string.IsNullOrWhiteSpace(input)) return;
        
        this.doPersist = input[0] == '#';
        if(doPersist) input = input.Remove(0,1);
        
        bool hasVariablesSection = input.Contains("||");
        string commandsSection = null;
        if (hasVariablesSection)
        {
            string variablesSection = null;
            try
            {
                variablesSection = input.Split(new[] { "||" }, StringSplitOptions.RemoveEmptyEntries)[0];
            }
            catch
            {
                error = "Missing variable declarations before the || operator";
                return;
            }
​
            string[] variableDefinitions = variablesSection.Split('|', StringSplitOptions.RemoveEmptyEntries);
            foreach (var varDefinition in variableDefinitions)
            {
                string[] varDefinitionTerms = varDefinition.Split(':', StringSplitOptions.RemoveEmptyEntries);
                string key = null;
                string value = null;
                try
                {
                    key = varDefinitionTerms[0];
                }
                catch
                {
                    error = "Missing key";
                    return;
                }
​
                try
                {
                    value = varDefinitionTerms[1];
                }
                catch
                {
                    error = "Missing value";
                    return;
                }
​
                variables.Add(key, value);
            }
​
            try
            {
                commandsSection = input.Split(new[] { "||" }, StringSplitOptions.RemoveEmptyEntries)[1];
            }
            catch
            {
                error = "Missing command(s) after variable declaration section";
                return;
            }
        }
        else
        {
            commandsSection = input;
        }
​
        string[] commands = commandsSection.Split(new[] { ";;" }, StringSplitOptions.RemoveEmptyEntries);
        for(int i = 0; i < commands.Length; i++)
        {
            commands[i] = commands[i].Trim();
        }
        foreach (var _command in commands)
        {
            string command = _command;
            if(string.IsNullOrWhiteSpace(command)) continue;
            
            bool doForce;
            if (command.Length >= 2) doForce = command.Substring(0,2).Contains('!');
            else doForce = command.Substring(0,1).Contains('!');
            if(doForce) command = StringUtils.ReplaceFirst(command,"!","");
            
            Command commandObject = new Command(command, variables,doForce);
            if(commandObject.command == "")
            {
                Console.WriteLine($"ERROR: Cannot find command '{command}'");
                continue;
            }
            this.commands.Add(commandObject);
        }
    }
}
​
public class Command
{
    public string command = "";
    public string[] arguments = [];
    public Dictionary<string, string> variables = [];
    public bool doForce;
    public CommandInfo commandInfo = null;
    
    public void Run()
    {
        commandInfo.behaviour?.Invoke(null,new[]{this});
    }
    
    public Command(string input, Dictionary<string, string> variables, bool doForce = false)
    {
        this.variables = variables;
        this.doForce = doForce;
        foreach (var cmdInfo in Commands.commands)
        {
            if (cmdInfo.IsValid(input))
            {
                command = cmdInfo.command;
                arguments = input.Remove(0, command.Length).Trim().Split(' ');
                break;
            }
        }
        
        for(int i = 0; i < arguments.Length; i++)
        {
            string arg = arguments[i];
            foreach(var variable in variables)
            {
                arg = arg.Replace($"&{variable.Key};",variable.Value);  
            }
            arguments[i] = arg;
        }
        
        foreach(var cmdInfo in Commands.commands)
        {
            if(cmdInfo.command == command && cmdInfo.IsValid(input))
            {
                this.commandInfo = cmdInfo;
                break;  
            }
        }
    }
​
    public override string ToString()
    {
        return $"{{doForce:{doForce},command:\"{command}\",arguments:[{string.Join(",", arguments)}]}}";
    }
}
​
public class CommandInfo
{
    public string command;
    public bool isMultiargument;
    public string[] arguments;
    public string help;
    public MethodInfo behaviour = null;
    
    public bool IsValid(string input)
    {
        if (input.Trim().Length < command.Length)
            return false;
        bool doesInputStartsWithCommandName = false;
        if (arguments.Length > 0)
        {
            doesInputStartsWithCommandName = input.StartsWith(command);
        }
        else
        {
            doesInputStartsWithCommandName = input.StartsWith(command);
        }
​
        bool hasCorrectArguments = false;
        string[] inputArguments = input.Remove(0, command.Length).Trim().Split(' ', StringSplitOptions.RemoveEmptyEntries);
        if (isMultiargument)
        {
            hasCorrectArguments = inputArguments.Length >= arguments.Length;
        }
        else
        {
            hasCorrectArguments = arguments.Length == inputArguments.Length;
        }
​
        return doesInputStartsWithCommandName && hasCorrectArguments;
    }
​
    public CommandInfo(string command, string[] arguments, bool isMultiargument, string help, string? behaviour = null)
    {
        this.command = command;
        this.arguments = arguments;
        this.isMultiargument = isMultiargument;
        this.help = help;
        this.behaviour = typeof(ConsoleMethods).GetMethod(behaviour ?? "");
    }
}
​
public static class Commands
{
    public static CommandInfo[] commands =
    {
        new("u say", new[] { "message" }, true, "Sends a message to Monika"),
        
        new("m say", new[] { "message" }, true, "Makes Monika say something","MSay"),
        new("m resp", new[] { "message" }, true, "Sends a message to Monika"),
        new("m cont", new string[] { }, false, "Continues with Monika's dialogue"),
        new("m expr", new[] { "pose", "expression" }, false, "Changes Monika's pose and expression"),
        new("m expr", new[] { "fullbody" }, false, "Changes Monika's pose and expression"),
        
        new("txb show", new string[] {}, false, "Shows the textbox"),
        new("txb show", new string[] {"message"}, true, "Sets the value of the textbox and shows it"),
        new("txb hide", new string[] {}, false, "Hide the textbox"),
        new("txb set", new string[] {"message"}, true, "Sets the value of the textbox"),
        
        new("wnd cfg", new string[] {}, false, "Opens the config window"),
        new("wnd msg", new string[] {}, false, "Opens the user message window"),
        new("wnd visuals", new string[] {}, false, "Opens the visuals window"),
        new("wnd controls", new string[] {}, false, "Opens the controls window"),
        new("wnd login", new string[] {}, false, "Opens the login window"),
        new("wnd console", new string[] {}, false, "Opens the console window"),
        new("wnd starterr", new string[] {}, false, "Opens the startup error window"),
        
        new("state get", new string[] {}, false, "Gets the application state"),
        new("state set", new string[] {"state"}, false, "Sets the application state"),
        
        new("data get", new string[] {}, false, "Gets the user data"),
        new("data rm", new string[] {"key"}, false, "Removes the user data"),
        
        new("app exit -f", new string[] {}, false, "Forces the application close","AppExitF"),
        new("app exit", new string[] {"motive"}, false, "Closes the application","AppExit"),
        
        new("yes", new string[] {}, false, "Confirms the action of a command"),
        new("no", new string[] {}, false, "Denies the action of a command"),
        new("key", new string[] {}, false, "Gets a random generated key"),
        new("var", new string[] {"name", "value"}, true, "Create or sets a variable"),
        new("help", new string[] {"command"}, true, "Displays the help menu of a specific command","HelpSpecific"),
        new("help", new string[] {}, false, "Displays the help menu","Help"),
        new("exit", new string[] {}, false, "Closes the console"),
    };
}
​
public static class ConsoleMethods
{
    public static void Help(Command cmd)
    {
        List<CommandInfo> commands = Commands.commands.ToList();
        for(int i = 0; i < commands.Count; i++)
        {
            CommandInfo cmdInfo = commands[i];
            
            List<string> messageSegments = [];
            messageSegments.Add(cmdInfo.command);
            
            if(cmdInfo.arguments.Length > 0)
            {
                string argsSegment = "";
                int j = 0;
                foreach(var arg in cmdInfo.arguments)
                {
                    if(j == cmdInfo.arguments.Length-1 && cmdInfo.isMultiargument)
                    argsSegment += $"<{arg}...> ";
                    else
                    argsSegment += $"<{arg}> ";
                    
                    j++;
                }
                argsSegment = argsSegment.Trim();
                messageSegments.Add(argsSegment);
            }
            
            messageSegments.Add($"| {cmdInfo.help}");
            
            string message = string.Join(" ",messageSegments);
            Console.WriteLine(message);
        }
    }
    
    public static void HelpSpecific(Command cmd)
    {
        List<CommandInfo> commands = [];
        string search = string.Join(" ",cmd.arguments);
        foreach(var command in Commands.commands)
        {
            if(command.command.StartsWith(search))
            {
                commands.Add(command);
            }
        }
        for(int i = 0; i < commands.Count; i++)
        {
            CommandInfo cmdInfo = commands[i];
            
            List<string> messageSegments = [];
            messageSegments.Add(cmdInfo.command);
            
            if(cmdInfo.arguments.Length > 0)
            {
                string argsSegment = "";
                int j = 0;
                foreach(var arg in cmdInfo.arguments)
                {
                    if(j == cmdInfo.arguments.Length-1 && cmdInfo.isMultiargument)
                    argsSegment += $"<{arg}...> ";
                    else
                    argsSegment += $"<{arg}> ";
                    
                    j++;
                }
                argsSegment = argsSegment.Trim();
                messageSegments.Add(argsSegment);
            }
            
            messageSegments.Add($"| {cmdInfo.help}");
            
            string message = string.Join(" ",messageSegments);
            Console.WriteLine(message);
        }
    }
    
    public static void AppExit(Command cmd)
    {
        Environment.Exit(0);    
    }
    public static void AppExitF(Command cmd)
    {
        Environment.Exit(0);    
    }
    public static void MSay(Command cmd)
    {
        string toSay = string.Join(" ",cmd.arguments);
        Console.WriteLine($"Monika: {toSay}");  
    }
}
​
public static class StringUtils
{
    public static string ReplaceFirst(string str, string term, string replace)
    {
        int position = str.IndexOf(term);
        if (position < 0)
        {
            return str;
        }
        str = str.Substring(0, position) + replace + str.Substring(position + term.Length);
        return str;
    }   
}

View IL Code