[SKIP_BUILD] Merge pull request #2393 from milutinke/1.19.3

Partial implementation for 1.19.3

.github/workflows/build-and-release.yml

@@ -8,7 +8,7 @@ on:
   
 env:
   PROJECT: "MinecraftClient"
-  target-version: "net6.0"
+  target-version: "net7.0"
   compile-flags: "--self-contained=true -c Release -p:UseAppHost=true -p:IncludeNativeLibrariesForSelfExtract=true -p:DebugType=None"
 
 jobs:
@@ -26,7 +26,7 @@ jobs:
         submodules: 'true'
 
     - name: Download translations from crowdin
-      uses: crowdin/github-action@1.5.0
+      uses: crowdin/github-action@1.6.0
       with:
         upload_sources: true
         upload_translations: false

.github/workflows/deploy-doc-only.yml

@@ -17,10 +17,10 @@ jobs:
         fetch-depth: 0
         submodules: 'true'
 
-    - name: Sync translations from crowdin
-      uses: crowdin/github-action@1.5.0
+    - name: Download translations from crowdin
+      uses: crowdin/github-action@1.6.0
       with:
-        upload_sources: true
+        upload_sources: false
         upload_translations: false
         download_translations: true
 

.github/workflows/update-translations-only.yml

@@ -1,4 +1,4 @@
-name: Sync Translations
+name: Upload translation sources
 
 on:
   workflow_dispatch:
@@ -15,12 +15,12 @@ jobs:
         fetch-depth: 0
         submodules: 'true'
 
-    - name: Sync translations from crowdin
-      uses: crowdin/github-action@1.5.0
+    - name: Upload translation sources to crowdin
+      uses: crowdin/github-action@1.6.0
       with:
         upload_sources: true
         upload_translations: false
-        download_translations: true
+        download_translations: false
 
         localization_branch_name: l10n_master
         create_pull_request: false 

.gitignore

@@ -409,8 +409,10 @@ FodyWeavers.xsd
 # translations
 /MinecraftClient/Resources/Translations/Translations.*.resx
 /MinecraftClient/Resources/AsciiArt/AsciiArt.*.resx
+/MinecraftClient/Resources/ConfigComments/ConfigComments.*.resx
 
 /docs/.vuepress/translations/*.json
 !/docs/.vuepress/translations/en.json
 
 /docs/l10n/
+/docs/.vuepress/public/MCC-README/

ConsoleInteractive

@@ -1 +1 @@
-Subproject commit 42074c449b8cf32e035f982bd83af6dcf75bc764
+Subproject commit 70bd2633b4ec6da62a2554f80a769e8178d825f2

MinecraftClient.sln

@@ -26,8 +26,8 @@ Global
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
-		RESX_SortFileContentOnSave = True
-		SolutionGuid = {6DED60F4-9CF4-4DB3-8966-582B2EBE8487}
 		RESX_ShowErrorsInErrorList = False
+		SolutionGuid = {6DED60F4-9CF4-4DB3-8966-582B2EBE8487}
+		RESX_SortFileContentOnSave = False
 	EndGlobalSection
 EndGlobal

MinecraftClient/ChatBots/Alerts.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots

MinecraftClient/ChatBots/AntiAFK.cs

@@ -1,5 +1,6 @@
 using System;
 using MinecraftClient.Mapping;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots

MinecraftClient/ChatBots/AutoAttack.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using MinecraftClient.Mapping;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots
@@ -32,6 +33,9 @@ namespace MinecraftClient.ChatBots
             [TomlInlineComment("$ChatBot.AutoAttack.Interaction$")]
             public InteractType Interaction = InteractType.Attack;
 
+            [TomlInlineComment("$ChatBot.AutoAttack.Attack_Range$")]
+            public double Attack_Range = 4.0;
+
             [TomlInlineComment("$ChatBot.AutoAttack.Attack_Hostile$")]
             public bool Attack_Hostile = true;
 
@@ -51,6 +55,12 @@ namespace MinecraftClient.ChatBots
                     LogToConsole(BotName, Translations.bot_autoAttack_invalidcooldown);
                     Cooldown_Time.value = 1.0;
                 }
+
+                if (Attack_Range < 1.0)
+                    Attack_Range = 1.0;
+
+                if (Attack_Range > 4.0)
+                    Attack_Range = 4.0;
             }
 
             public enum AttackMode { single, multi };
@@ -90,7 +100,7 @@ namespace MinecraftClient.ChatBots
         private Double attackSpeed = 4;
         private Double attackCooldownSeconds;
         private readonly bool overrideAttackSpeed = false;
-        private readonly int attackRange = 4;
+        private readonly double attackRange = 4.0;
         private Double serverTPS;
         private float health = 100;
         private readonly bool attackHostile = true;
@@ -107,6 +117,7 @@ namespace MinecraftClient.ChatBots
 
             attackHostile = Config.Attack_Hostile;
             attackPassive = Config.Attack_Passive;
+            attackRange = Config.Attack_Range;
         }
 
         public override void Initialize()

MinecraftClient/ChatBots/AutoCraft.cs

@@ -2,8 +2,13 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.CommandHandler.Patch;
 using MinecraftClient.Inventory;
 using MinecraftClient.Mapping;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 using static MinecraftClient.ChatBots.AutoCraft.Configs;
 
@@ -11,6 +16,8 @@ namespace MinecraftClient.ChatBots
 {
     public class AutoCraft : ChatBot
     {
+        public const string CommandName = "autocraft";
+
         public static Configs Config = new();
 
         [TomlDoNotInlineObject]
@@ -288,26 +295,66 @@ namespace MinecraftClient.ChatBots
                 UnloadBot();
                 return;
             }
-            RegisterChatBotCommand("autocraft", Translations.bot_autoCraft_cmd, GetHelp(), CommandHandler);
-            RegisterChatBotCommand("ac", Translations.bot_autoCraft_alias, GetHelp(), CommandHandler);
+
+            McClient.dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CommandName)
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Then(l => l.Literal("list")
+                        .Executes(r => OnCommandHelp(r.Source, "list")))
+                    .Then(l => l.Literal("start")
+                        .Executes(r => OnCommandHelp(r.Source, "start")))
+                    .Then(l => l.Literal("stop")
+                        .Executes(r => OnCommandHelp(r.Source, "stop")))
+                    .Then(l => l.Literal("help")
+                        .Executes(r => OnCommandHelp(r.Source, "help")))
+                )
+            );
+
+            McClient.dispatcher.Register(l => l.Literal(CommandName)
+                .Then(l => l.Literal("list")
+                    .Executes(r => OnCommandList(r.Source)))
+                .Then(l => l.Literal("start")
+                    .Then(l => l.Argument("RecipeName", MccArguments.AutoCraftRecipeName())
+                        .Executes(r => OnCommandStart(r.Source, Arguments.GetString(r, "RecipeName")))))
+                .Then(l => l.Literal("stop")
+                    .Executes(r => OnCommandStop(r.Source)))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Redirect(McClient.dispatcher.GetRoot().GetChild("help").GetChild(CommandName)))
+            );
         }
 
-        public string CommandHandler(string cmd, string[] args)
+        public override void OnUnload()
         {
-            if (args.Length > 0)
+            McClient.dispatcher.Unregister(CommandName);
+            McClient.dispatcher.GetRoot().GetChild("help").RemoveChild(CommandName);
+        }
+
+        private int OnCommandHelp(CmdResult r, string? cmd)
         {
-                switch (args[0])
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                "list"      =>   Translations.bot_autoCraft_help_list,
+                "start"     =>   Translations.bot_autoCraft_help_start,
+                "stop"      =>   Translations.bot_autoCraft_help_stop,
+                "help"      =>   Translations.bot_autoCraft_help_help,
+                _           =>   string.Format(Translations.bot_autoCraft_available_cmd, "load, list, reload, resetcfg, start, stop, help")
+                                   + '\n' + McClient.dispatcher.GetAllUsageString(CommandName, false),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int OnCommandList(CmdResult r)
         {
-                    case "list":
             StringBuilder nameList = new();
             foreach (RecipeConfig recipe in Config.Recipes)
                 nameList.Append(recipe.Name).Append(", ");
-                        return string.Format(Translations.bot_autoCraft_cmd_list, Config.Recipes.Length, nameList.ToString());
-                    case "start":
-                        if (args.Length >= 2)
-                        {
-                            string name = args[1];
+            return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.bot_autoCraft_cmd_list, Config.Recipes.Length, nameList.ToString()));
+        }
 
+        private int OnCommandStart(CmdResult r, string name)
+        {
             bool hasRecipe = false;
             RecipeConfig? recipe = null;
             foreach (RecipeConfig recipeConfig in Config.Recipes)
@@ -324,45 +371,18 @@ namespace MinecraftClient.ChatBots
             {
                 ResetVar();
                 PrepareCrafting(recipe!);
-                                return "";
+                return r.SetAndReturn(CmdResult.Status.Done);
             }
             else
-                                return Translations.bot_autoCraft_recipe_not_exist;
+            {
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.bot_autoCraft_recipe_not_exist);
             }
-                        else
-                            return Translations.bot_autoCraft_no_recipe_name;
-                    case "stop":
+        }
+
+        private int OnCommandStop(CmdResult r)
+        {
             StopCrafting();
-                        return Translations.bot_autoCraft_stop;
-                    case "help":
-                        return GetCommandHelp(args.Length >= 2 ? args[1] : "");
-                    default:
-                        return GetHelp();
-                }
-            }
-            else return GetHelp();
-        }
-
-        private static string GetHelp()
-        {
-            return string.Format(Translations.bot_autoCraft_available_cmd, "load, list, reload, resetcfg, start, stop, help");
-        }
-
-        private string GetCommandHelp(string cmd)
-        {
-            return cmd.ToLower() switch
-            {
-#pragma warning disable format // @formatter:off
-                "load"      =>   Translations.bot_autoCraft_help_load,
-                "list"      =>   Translations.bot_autoCraft_help_list,
-                "reload"    =>   Translations.bot_autoCraft_help_reload,
-                "resetcfg"  =>   Translations.bot_autoCraft_help_resetcfg,
-                "start"     =>   Translations.bot_autoCraft_help_start,
-                "stop"      =>   Translations.bot_autoCraft_help_stop,
-                "help"      =>   Translations.bot_autoCraft_help_help,
-                _           =>    GetHelp(),
-#pragma warning restore format // @formatter:on
-            };
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.bot_autoCraft_stop);
         }
 
         #region Core part of auto-crafting

MinecraftClient/ChatBots/AutoDig.cs

@@ -1,13 +1,19 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.CommandHandler.Patch;
 using MinecraftClient.Mapping;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots
 {
     public class AutoDig : ChatBot
     {
+        public const string CommandName = "autodig";
+
         public static Configs Config = new();
 
         [TomlDoNotInlineObject]
@@ -117,32 +123,68 @@ namespace MinecraftClient.ChatBots
             if (!inventoryEnabled && Config.Auto_Tool_Switch)
                 LogToConsole(Translations.bot_autodig_no_inv_handle);
 
-            RegisterChatBotCommand("digbot", Translations.bot_autodig_cmd, GetHelp(), CommandHandler);
+            McClient.dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CommandName)
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Then(l => l.Literal("start")
+                        .Executes(r => OnCommandHelp(r.Source, "start")))
+                    .Then(l => l.Literal("stop")
+                        .Executes(r => OnCommandHelp(r.Source, "stop")))
+                    .Then(l => l.Literal("help")
+                        .Executes(r => OnCommandHelp(r.Source, "help")))
+                )
+            );
+
+            var cmd = McClient.dispatcher.Register(l => l.Literal(CommandName)
+                .Then(l => l.Literal("start")
+                    .Executes(r => OnCommandStart(r.Source)))
+                .Then(l => l.Literal("stop")
+                    .Executes(r => OnCommandStop(r.Source)))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Redirect(McClient.dispatcher.GetRoot().GetChild("help").GetChild(CommandName)))
+            );
+
+            McClient.dispatcher.Register(l => l.Literal("digbot")
+                .Redirect(cmd)
+            );
         }
 
-        public string CommandHandler(string cmd, string[] args)
+        public override void OnUnload()
         {
-            if (args.Length > 0)
+            McClient.dispatcher.Unregister("digbot");
+            McClient.dispatcher.Unregister(CommandName);
+            McClient.dispatcher.GetRoot().GetChild("help").RemoveChild(CommandName);
+        }
+
+        private int OnCommandHelp(CmdResult r, string? cmd)
         {
-                switch (args[0])
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                "start"     =>   Translations.bot_autodig_help_start,
+                "stop"      =>   Translations.bot_autodig_help_stop,
+                "help"      =>   Translations.bot_autodig_help_help,
+                _           =>   string.Format(Translations.bot_autodig_available_cmd, "start, stop, help")
+                                   + '\n' + McClient.dispatcher.GetAllUsageString(CommandName, false),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int OnCommandStart(CmdResult r)
         {
-                    case "start":
             lock (stateLock)
             {
                 counter = 0;
                 state = State.WaitingStart;
             }
-                        return Translations.bot_autodig_start;
-                    case "stop":
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.bot_autodig_start);
+        }
+
+        private int OnCommandStop(CmdResult r)
+        {
             StopDigging();
-                        return Translations.bot_autodig_stop;
-                    case "help":
-                        return GetCommandHelp(args.Length >= 2 ? args[1] : "");
-                    default:
-                        return GetHelp();
-                }
-            }
-            else return GetHelp();
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.bot_autodig_stop);
         }
 
         private void StartDigging()
@@ -401,23 +443,5 @@ namespace MinecraftClient.ChatBots
 
             return base.OnDisconnect(reason, message);
         }
-
-        private static string GetHelp()
-        {
-            return string.Format(Translations.bot_autodig_available_cmd, "start, stop, help");
-        }
-
-        private string GetCommandHelp(string cmd)
-        {
-            return cmd.ToLower() switch
-            {
-#pragma warning disable format // @formatter:off
-                "start"     =>   Translations.bot_autodig_help_start,
-                "stop"      =>   Translations.bot_autodig_help_stop,
-                "help"      =>   Translations.bot_autodig_help_help,
-                _           =>    GetHelp(),
-#pragma warning restore format // @formatter:on
-            };
-        }
     }
 }

MinecraftClient/ChatBots/AutoDrop.cs

@@ -1,7 +1,11 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.CommandHandler.Patch;
 using MinecraftClient.Inventory;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 using static MinecraftClient.ChatBots.AutoDrop.Configs;
 
@@ -9,6 +13,8 @@ namespace MinecraftClient.ChatBots
 {
     public class AutoDrop : ChatBot
     {
+        public const string CommandName = "autodrop";
+
         public static Configs Config = new();
 
         [TomlDoNotInlineObject]
@@ -38,110 +44,6 @@ namespace MinecraftClient.ChatBots
         private readonly int updateDebounceValue = 2;
         private int inventoryUpdated = -1;
 
-        public string CommandHandler(string cmd, string[] args)
-        {
-            if (args.Length > 0)
-            {
-                switch (args[0].ToLower())
-                {
-                    case "on":
-                        Config.Enabled = true;
-                        inventoryUpdated = 0;
-                        OnUpdateFinish();
-                        return Translations.bot_autoDrop_on;
-                    case "off":
-                        Config.Enabled = false;
-                        return Translations.bot_autoDrop_off;
-                    case "add":
-                        if (args.Length >= 2)
-                        {
-                            if (Enum.TryParse(args[1], true, out ItemType item))
-                            {
-                                Config.Items.Add(item);
-                                return string.Format(Translations.bot_autoDrop_added, item.ToString());
-                            }
-                            else
-                            {
-                                return string.Format(Translations.bot_autoDrop_incorrect_name, args[1]);
-                            }
-                        }
-                        else
-                        {
-                            return Translations.cmd_inventory_help_usage + ": add <item name>";
-                        }
-                    case "remove":
-                        if (args.Length >= 2)
-                        {
-                            if (Enum.TryParse(args[1], true, out ItemType item))
-                            {
-                                if (Config.Items.Contains(item))
-                                {
-                                    Config.Items.Remove(item);
-                                    return string.Format(Translations.bot_autoDrop_removed, item.ToString());
-                                }
-                                else
-                                {
-                                    return Translations.bot_autoDrop_not_in_list;
-                                }
-                            }
-                            else
-                            {
-                                return string.Format(Translations.bot_autoDrop_incorrect_name, args[1]);
-                            }
-                        }
-                        else
-                        {
-                            return Translations.cmd_inventory_help_usage + ": remove <item name>";
-                        }
-                    case "list":
-                        if (Config.Items.Count > 0)
-                        {
-                            return string.Format(Translations.bot_autoDrop_list, Config.Items.Count, string.Join("\n", Config.Items));
-                        }
-                        else
-                        {
-                            return Translations.bot_autoDrop_no_item;
-                        }
-                    case "mode":
-                        if (args.Length >= 2)
-                        {
-                            switch (args[1].ToLower())
-                            {
-                                case "include":
-                                    Config.Mode = DropMode.include;
-                                    break;
-                                case "exclude":
-                                    Config.Mode = DropMode.exclude;
-                                    break;
-                                case "everything":
-                                    Config.Mode = DropMode.everything;
-                                    break;
-                                default:
-                                    return Translations.bot_autoDrop_unknown_mode; // Unknwon mode. Available modes: Include, Exclude, Everything
-                            }
-                            inventoryUpdated = 0;
-                            OnUpdateFinish();
-                            return string.Format(Translations.bot_autoDrop_switched, Config.Mode.ToString()); // Switched to {0} mode.
-                        }
-                        else
-                        {
-                            return Translations.bot_autoDrop_unknown_mode;
-                        }
-                    default:
-                        return GetHelp();
-                }
-            }
-            else
-            {
-                return GetHelp();
-            }
-        }
-
-        private static string GetHelp()
-        {
-            return string.Format(Translations.general_available_cmd, "on, off, add, remove, list, mode");
-        }
-
         public override void Initialize()
         {
             if (!GetInventoryEnabled())
@@ -151,8 +53,114 @@ namespace MinecraftClient.ChatBots
                 UnloadBot();
                 return;
             }
-            RegisterChatBotCommand("autodrop", Translations.bot_autoDrop_cmd, GetHelp(), CommandHandler);
-            RegisterChatBotCommand("ad", Translations.bot_autoDrop_alias, GetHelp(), CommandHandler);
+
+            McClient.dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CommandName)
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Then(l => l.Literal("add")
+                        .Executes(r => OnCommandHelp(r.Source, "add")))
+                    .Then(l => l.Literal("remove")
+                        .Executes(r => OnCommandHelp(r.Source, "remove")))
+                    .Then(l => l.Literal("mode")
+                        .Executes(r => OnCommandHelp(r.Source, "mode")))
+                )
+            );
+
+            McClient.dispatcher.Register(l => l.Literal(CommandName)
+                .Then(l => l.Literal("on")
+                    .Executes(r => OnCommandEnable(r.Source, true)))
+                .Then(l => l.Literal("off")
+                    .Executes(r => OnCommandEnable(r.Source, false)))
+                .Then(l => l.Literal("add")
+                    .Then(l => l.Argument("ItemType", MccArguments.ItemType())
+                        .Executes(r => OnCommandAdd(r.Source, MccArguments.GetItemType(r, "ItemType")))))
+                .Then(l => l.Literal("remove")
+                    .Then(l => l.Argument("ItemType", MccArguments.ItemType())
+                        .Executes(r => OnCommandRemove(r.Source, MccArguments.GetItemType(r, "ItemType")))))
+                .Then(l => l.Literal("list")
+                    .Executes(r => OnCommandList(r.Source)))
+                .Then(l => l.Literal("mode")
+                    .Then(l => l.Literal("include")
+                        .Executes(r => OnCommandMode(r.Source, DropMode.include)))
+                    .Then(l => l.Literal("exclude")
+                        .Executes(r => OnCommandMode(r.Source, DropMode.exclude)))
+                    .Then(l => l.Literal("everything")
+                        .Executes(r => OnCommandMode(r.Source, DropMode.everything))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Redirect(McClient.dispatcher.GetRoot().GetChild("help").GetChild(CommandName)))
+            );
+        }
+
+        public override void OnUnload()
+        {
+            McClient.dispatcher.Unregister(CommandName);
+            McClient.dispatcher.GetRoot().GetChild("help").RemoveChild(CommandName);
+        }
+
+        private int OnCommandHelp(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                "add"       =>   Translations.cmd_inventory_help_usage + ": add <item name>",
+                "remove"    =>   Translations.cmd_inventory_help_usage + ": remove <item name>",
+                "mode"      =>   Translations.bot_autoDrop_unknown_mode,
+                _           =>   string.Format(Translations.general_available_cmd, "on, off, add, remove, list, mode")
+                                   + '\n' + McClient.dispatcher.GetAllUsageString(CommandName, false),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int OnCommandEnable(CmdResult r, bool enable)
+        {
+            if (enable)
+            {
+                Config.Enabled = true;
+                inventoryUpdated = 0;
+                OnUpdateFinish();
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.bot_autoDrop_on);
+            }
+            else
+            {
+                Config.Enabled = false;
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.bot_autoDrop_off);
+            }
+        }
+
+        private int OnCommandAdd(CmdResult r, ItemType item)
+        {
+            Config.Items.Add(item);
+            return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.bot_autoDrop_added, item.ToString()));
+        }
+
+        private int OnCommandRemove(CmdResult r, ItemType item)
+        {
+            if (Config.Items.Contains(item))
+            {
+                Config.Items.Remove(item);
+                return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.bot_autoDrop_removed, item.ToString()));
+            }
+            else
+            {
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.bot_autoDrop_not_in_list);
+            }
+        }
+
+        private int OnCommandList(CmdResult r)
+        {
+            if (Config.Items.Count > 0)
+                return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.bot_autoDrop_list, Config.Items.Count, string.Join("\n", Config.Items)));
+            else
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.bot_autoDrop_no_item);
+        }
+
+        private int OnCommandMode(CmdResult r, DropMode mode)
+        {
+            Config.Mode = mode;
+            inventoryUpdated = 0;
+            OnUpdateFinish();
+            return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.bot_autoDrop_switched, Config.Mode.ToString()));
         }
 
         public override void Update()

MinecraftClient/ChatBots/AutoEat.cs

@@ -1,5 +1,6 @@
 using System;
 using MinecraftClient.Inventory;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots

MinecraftClient/ChatBots/AutoFishing.cs

@@ -2,8 +2,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.CommandHandler.Patch;
 using MinecraftClient.Inventory;
 using MinecraftClient.Mapping;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 using static MinecraftClient.ChatBots.AutoFishing.Configs;
 
@@ -15,6 +19,8 @@ namespace MinecraftClient.ChatBots
     /// </summary>
     public class AutoFishing : ChatBot
     {
+        public const string CommandName = "autofishing";
+
         public static Configs Config = new();
 
         [TomlDoNotInlineObject]
@@ -176,20 +182,63 @@ namespace MinecraftClient.ChatBots
                 LogToConsole(Translations.extra_entity_required);
                 state = FishingState.WaitJoinGame;
             }
+
             inventoryEnabled = GetInventoryEnabled();
             if (!inventoryEnabled)
                 LogToConsole(Translations.bot_autoFish_no_inv_handle);
 
-            RegisterChatBotCommand("fish", Translations.bot_autoFish_cmd, GetHelp(), CommandHandler);
+            McClient.dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CommandName)
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Then(l => l.Literal("start")
+                        .Executes(r => OnCommandHelp(r.Source, "start")))
+                    .Then(l => l.Literal("stop")
+                        .Executes(r => OnCommandHelp(r.Source, "stop")))
+                    .Then(l => l.Literal("status")
+                        .Executes(r => OnCommandHelp(r.Source, "status")))
+                    .Then(l => l.Literal("help")
+                        .Executes(r => OnCommandHelp(r.Source, "help")))
+                )
+            );
+
+            McClient.dispatcher.Register(l => l.Literal(CommandName)
+                .Then(l => l.Literal("start")
+                    .Executes(r => OnCommandStart(r.Source)))
+                .Then(l => l.Literal("stop")
+                    .Executes(r => OnCommandStop(r.Source)))
+                .Then(l => l.Literal("status")
+                    .Executes(r => OnCommandStatus(r.Source))
+                    .Then(l => l.Literal("clear")
+                        .Executes(r => OnCommandStatusClear(r.Source))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Redirect(McClient.dispatcher.GetRoot().GetChild("help").GetChild(CommandName)))
+            );
         }
 
-        public string CommandHandler(string cmd, string[] args)
+        public override void OnUnload()
         {
-            if (args.Length >= 1)
+            McClient.dispatcher.Unregister(CommandName);
+            McClient.dispatcher.GetRoot().GetChild("help").RemoveChild(CommandName);
+        }
+
+        private int OnCommandHelp(CmdResult r, string? cmd)
         {
-                switch (args[0])
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                "start"     =>   Translations.bot_autoFish_help_start,
+                "stop"      =>   Translations.bot_autoFish_help_stop,
+                "status"    =>   Translations.bot_autoFish_help_status,
+                "help"      =>   Translations.bot_autoFish_help_help,
+                _           =>   string.Format(Translations.bot_autoFish_available_cmd, "start, stop, status, help")
+                                   + '\n' + McClient.dispatcher.GetAllUsageString(CommandName, false),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int OnCommandStart(CmdResult r)
         {
-                    case "start":
             isFishing = false;
             lock (stateLock)
             {
@@ -197,8 +246,11 @@ namespace MinecraftClient.ChatBots
                 counter = 0;
                 state = FishingState.StartMove;
             }
-                        return Translations.bot_autoFish_start;
-                    case "stop":
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.bot_autoFish_start);
+        }
+
+        private int OnCommandStop(CmdResult r)
+        {
             isFishing = false;
             lock (stateLock)
             {
@@ -208,24 +260,13 @@ namespace MinecraftClient.ChatBots
                 state = FishingState.Stopping;
             }
             StopFishing();
-                        return Translations.bot_autoFish_stop;
-                    case "status":
-                        if (args.Length >= 2)
-                        {
-                            if (args[1] == "clear")
-                            {
-                                fishItemCnt = new();
-                                return Translations.bot_autoFish_status_clear;
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.bot_autoFish_stop);
         }
-                            else
-                            {
-                                return GetCommandHelp("status");
-                            }
-                        }
-                        else
+
+        private int OnCommandStatus(CmdResult r)
         {
             if (fishItemCnt.Count == 0)
-                                return Translations.bot_autoFish_status_info;
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.bot_autoFish_status_info);
 
             List<KeyValuePair<ItemType, uint>> orderedList = fishItemCnt.OrderBy(x => x.Value).ToList();
             int maxLen = orderedList[^1].Value.ToString().Length;
@@ -240,16 +281,14 @@ namespace MinecraftClient.ChatBots
                 sb.Append(" x ");
                 sb.Append(Item.GetTypeString(type));
             }
-                            return sb.ToString();
+            LogToConsole(sb.ToString());
+            return r.SetAndReturn(CmdResult.Status.Done);
         }
-                    case "help":
-                        return GetCommandHelp(args.Length >= 2 ? args[1] : "");
-                    default:
-                        return GetHelp();
-                }
-            }
-            else
-                return GetHelp();
+
+        private int OnCommandStatusClear(CmdResult r)
+        {
+            fishItemCnt = new();
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.bot_autoFish_status_clear);
         }
 
         private void StartFishing()
@@ -620,24 +659,5 @@ namespace MinecraftClient.ChatBots
                 return false;
             }
         }
-
-        private static string GetHelp()
-        {
-            return string.Format(Translations.bot_autoFish_available_cmd, "start, stop, status, help");
-        }
-
-        private string GetCommandHelp(string cmd)
-        {
-            return cmd.ToLower() switch
-            {
-#pragma warning disable format // @formatter:off
-                "start"     =>   Translations.bot_autoFish_help_start,
-                "stop"      =>   Translations.bot_autoFish_help_stop,
-                "status"    =>   Translations.bot_autoFish_help_status,
-                "help"      =>   Translations.bot_autoFish_help_help,
-                _           =>   GetHelp(),
-#pragma warning restore format // @formatter:on
-            };
-        }
     }
 }

MinecraftClient/ChatBots/AutoRelog.cs

@@ -1,4 +1,5 @@
 using System;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots
@@ -83,6 +84,11 @@ namespace MinecraftClient.ChatBots
         }
 
         public override void Initialize()
+        {
+            _Initialize();
+        }
+
+        private void _Initialize()
         {
             McClient.ReconnectionAttemptsLeft = Config.Retries;
             if (Config.Ignore_Kick_Message)

MinecraftClient/ChatBots/AutoRespond.cs

@@ -4,6 +4,8 @@ using System.Globalization;
 using System.IO;
 using System.Text;
 using System.Text.RegularExpressions;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 using static MinecraftClient.Settings;
 
@@ -304,12 +306,12 @@ namespace MinecraftClient.ChatBots
                 {
                     Dictionary<string, object> localVars = new();
                     string? toPerform = rule.Match(sender, message, msgType, localVars);
-                    if (!String.IsNullOrEmpty(toPerform))
+                    if (!string.IsNullOrEmpty(toPerform))
                     {
-                        string? response = null;
+                        CmdResult response = new();
                         LogToConsole(string.Format(Translations.bot_autoRespond_match_run, toPerform));
                         PerformInternalCommand(toPerform, ref response, localVars);
-                        if (!String.IsNullOrEmpty(response))
+                        if (response.status != CmdResult.Status.Done || !string.IsNullOrWhiteSpace(response.result))
                             LogToConsole(response);
                     }
                 }

MinecraftClient/ChatBots/ChatLog.cs

@@ -1,5 +1,7 @@
 using System;
 using System.IO;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots
@@ -115,7 +117,7 @@ namespace MinecraftClient.ChatBots
             }
         }
 
-        public override void OnInternalCommand(string commandName, string commandParams, string result)
+        public override void OnInternalCommand(string commandName, string commandParams, CmdResult result)
         {
             if (saveInternal)
             {

MinecraftClient/ChatBots/DiscordBridge.cs

@@ -3,16 +3,22 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using Brigadier.NET.Builder;
 using DSharpPlus;
 using DSharpPlus.Entities;
 using DSharpPlus.Exceptions;
 using Microsoft.Extensions.Logging;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.CommandHandler.Patch;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots
 {
     public class DiscordBridge : ChatBot
     {
+        public const string CommandName = "dscbridge";
+
         private enum BridgeDirection
         {
             Both = 0,
@@ -70,17 +76,74 @@ namespace MinecraftClient.ChatBots
 
         public override void Initialize()
         {
-            RegisterChatBotCommand("dscbridge", "bot.DiscordBridge.desc", "dscbridge direction <both|mc|discord>", OnDscCommand);
+            McClient.dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CommandName)
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                )
+            );
+
+            McClient.dispatcher.Register(l => l.Literal(CommandName)
+                .Then(l => l.Literal("direction")
+                    .Then(l => l.Literal("both")
+                        .Executes(r => OnCommandDirection(r.Source, BridgeDirection.Both)))
+                    .Then(l => l.Literal("mc")
+                        .Executes(r => OnCommandDirection(r.Source, BridgeDirection.Minecraft)))
+                    .Then(l => l.Literal("discord")
+                        .Executes(r => OnCommandDirection(r.Source, BridgeDirection.Discord)))
+                )
+                .Then(l => l.Literal("_help")
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Redirect(McClient.dispatcher.GetRoot().GetChild("help").GetChild(CommandName)))
+            );
 
             Task.Run(async () => await MainAsync());
         }
 
-        ~DiscordBridge()
+        public override void OnUnload()
         {
+            McClient.dispatcher.Unregister(CommandName);
+            McClient.dispatcher.GetRoot().GetChild("help").RemoveChild(CommandName);
             Disconnect();
         }
 
-        public override void OnUnload()
+        private int OnCommandHelp(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>   "dscbridge direction <both|mc|discord>"
+                                   + '\n' + McClient.dispatcher.GetAllUsageString(CommandName, false),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int OnCommandDirection(CmdResult r, BridgeDirection direction)
+        {
+            string bridgeName;
+            switch (direction)
+            {
+                case BridgeDirection.Both:
+                    bridgeName = Translations.bot_DiscordBridge_direction_both;
+                    bridgeDirection = BridgeDirection.Both;
+                    break;
+
+                case BridgeDirection.Minecraft:
+                    bridgeName = Translations.bot_DiscordBridge_direction_minecraft;
+                    bridgeDirection = BridgeDirection.Minecraft;
+                    break;
+
+                case BridgeDirection.Discord:
+                    bridgeName = Translations.bot_DiscordBridge_direction_discord;
+                    bridgeDirection = BridgeDirection.Discord;
+                    break;
+
+                default:
+                    goto case BridgeDirection.Both;
+            }
+            return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.bot_DiscordBridge_direction, bridgeName));
+        }
+
+        ~DiscordBridge()
         {
             Disconnect();
         }
@@ -100,7 +163,7 @@ namespace MinecraftClient.ChatBots
                 }
                 catch (Exception e)
                 {
-                    LogToConsole("§w§l§f" + Translations.bot_DiscordBridge_canceled_sending);
+                    LogToConsole("§§4§l§f" + Translations.bot_DiscordBridge_canceled_sending);
                     LogDebugToConsole(e);
                 }
 
@@ -114,47 +177,6 @@ namespace MinecraftClient.ChatBots
             return instance;
         }
 
-        private string OnDscCommand(string cmd, string[] args)
-        {
-            if (args.Length == 2)
-            {
-                if (args[0].ToLower().Equals("direction"))
-                {
-                    string direction = args[1].ToLower().Trim();
-
-                    string bridgeName;
-                    switch (direction)
-                    {
-                        case "b":
-                        case "both":
-                            bridgeName = Translations.bot_DiscordBridge_direction_both;
-                            bridgeDirection = BridgeDirection.Both;
-                            break;
-
-                        case "mc":
-                        case "minecraft":
-                            bridgeName = Translations.bot_DiscordBridge_direction_minecraft;
-                            bridgeDirection = BridgeDirection.Minecraft;
-                            break;
-
-                        case "d":
-                        case "dcs":
-                        case "discord":
-                            bridgeName = Translations.bot_DiscordBridge_direction_discord;
-                            bridgeDirection = BridgeDirection.Discord;
-                            break;
-
-                        default:
-                            return Translations.bot_DiscordBridge_invalid_direction;
-                    }
-
-                    return string.Format(Translations.bot_DiscordBridge_direction, bridgeName);
-                };
-            }
-
-            return "dscbridge direction <both|mc|discord>";
-        }
-
         public override void GetText(string text)
         {
             if (!CanSendMessages())
@@ -211,7 +233,7 @@ namespace MinecraftClient.ChatBots
             }
             catch (Exception e)
             {
-                LogToConsole("§w§l§f" + Translations.bot_DiscordBridge_canceled_sending);
+                LogToConsole("§§4§l§f" + Translations.bot_DiscordBridge_canceled_sending);
                 LogDebugToConsole(e);
             }
         }
@@ -227,7 +249,7 @@ namespace MinecraftClient.ChatBots
             }
             catch (Exception e)
             {
-                LogToConsole("§w§l§f" + Translations.bot_DiscordBridge_canceled_sending);
+                LogToConsole("§§4§l§f" + Translations.bot_DiscordBridge_canceled_sending);
                 LogDebugToConsole(e);
             }
         }
@@ -243,7 +265,7 @@ namespace MinecraftClient.ChatBots
             }
             catch (Exception e)
             {
-                LogToConsole("§w§l§f" + Translations.bot_DiscordBridge_canceled_sending);
+                LogToConsole("§§4§l§f" + Translations.bot_DiscordBridge_canceled_sending);
                 LogDebugToConsole(e);
             }
         }
@@ -269,7 +291,7 @@ namespace MinecraftClient.ChatBots
             }
             catch (Exception e)
             {
-                LogToConsole("§w§l§f" + Translations.bot_DiscordBridge_canceled_sending);
+                LogToConsole("§§4§l§f" + Translations.bot_DiscordBridge_canceled_sending);
                 LogDebugToConsole(e);
             }
         }
@@ -369,9 +391,8 @@ namespace MinecraftClient.ChatBots
                         message = message[1..];
                         await e.Message.CreateReactionAsync(DiscordEmoji.FromName(discordBotClient, ":gear:"));
 
-                        string? result = "";
+                        CmdResult result = new();
                         PerformInternalCommand(message, ref result);
-                        result = string.IsNullOrEmpty(result) ? "-" : result;
 
                         await e.Message.DeleteOwnReactionAsync(DiscordEmoji.FromName(discordBotClient, ":gear:"));
                         await e.Message.CreateReactionAsync(DiscordEmoji.FromName(discordBotClient, ":white_check_mark:"));
@@ -399,12 +420,12 @@ namespace MinecraftClient.ChatBots
                 });
 
                 IsConnected = true;
-                LogToConsole("§y§l§f" + Translations.bot_DiscordBridge_connected);
+                LogToConsole("§§2§l§f" + Translations.bot_DiscordBridge_connected);
                 await Task.Delay(-1);
             }
             catch (Exception e)
             {
-                LogToConsole("§w§l§f" + Translations.bot_DiscordBridge_unknown_error);
+                LogToConsole("§§4§l§f" + Translations.bot_DiscordBridge_unknown_error);
                 LogToConsole(e);
                 return;
             }

MinecraftClient/ChatBots/Farmer.cs

@@ -3,34 +3,22 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Threading;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.CommandHandler.Patch;
 using MinecraftClient.Inventory;
 using MinecraftClient.Mapping;
 using MinecraftClient.Protocol.Handlers;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots
 {
-    enum State
-    {
-        SearchingForCropsToBreak = 0,
-        SearchingForFarmlandToPlant,
-        PlantingCrops,
-        BonemealingCrops
-    }
-
-    enum CropType
-    {
-        Beetroot,
-        Carrot,
-        Melon,
-        Netherwart,
-        Pumpkin,
-        Potato,
-        Wheat
-    }
-
     public class Farmer : ChatBot
     {
+        public const string CommandName = "farmer";
+
         public static Configs Config = new();
 
         [TomlDoNotInlineObject]
@@ -42,15 +30,34 @@ namespace MinecraftClient.ChatBots
             public bool Enabled = false;
 
             [TomlInlineComment("$ChatBot.Farmer.Delay_Between_Tasks$")]
-            public int Delay_Between_Tasks = 1;
+            public double Delay_Between_Tasks = 1.0;
 
             public void OnSettingUpdate()
             {
-                if (Delay_Between_Tasks <= 0)
-                    Delay_Between_Tasks = 1;
+                if (Delay_Between_Tasks < 1.0)
+                    Delay_Between_Tasks = 1.0;
             }
         }
 
+        public enum State
+        {
+            SearchingForCropsToBreak = 0,
+            SearchingForFarmlandToPlant,
+            PlantingCrops,
+            BonemealingCrops
+        }
+
+        public enum CropType
+        {
+            Beetroot,
+            Carrot,
+            Melon,
+            Netherwart,
+            Pumpkin,
+            Potato,
+            Wheat
+        }
+
         private State state = State.SearchingForCropsToBreak;
         private CropType cropType = CropType.Wheat;
         private int farmingRadius = 30;
@@ -59,6 +66,8 @@ namespace MinecraftClient.ChatBots
         private bool allowTeleport = false;
         private bool debugEnabled = false;
 
+        public int Delay_Between_Tasks_Millisecond => (int)Math.Round(Config.Delay_Between_Tasks * 1000);
+
         private const string commandDescription = "farmer <start <crop type> [radius:<radius = 30>] [unsafe:<true/false>] [teleport:<true/false>] [debug:<true/false>]|stop>";
 
         public override void Initialize()
@@ -81,31 +90,60 @@ namespace MinecraftClient.ChatBots
                 return;
             }
 
-            RegisterChatBotCommand("farmer", "bot.farmer.desc", commandDescription, OnFarmCommand);
+            McClient.dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CommandName)
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                )
+            );
+
+            McClient.dispatcher.Register(l => l.Literal(CommandName)
+                .Then(l => l.Literal("stop")
+                    .Executes(r => OnCommandStop(r.Source)))
+                .Then(l => l.Literal("start")
+                    .Then(l => l.Argument("CropType", MccArguments.FarmerCropType())
+                        .Executes(r => OnCommandStart(r.Source, MccArguments.GetFarmerCropType(r, "CropType"), null))
+                        .Then(l => l.Argument("OtherArgs", Arguments.GreedyString())
+                            .Executes(r => OnCommandStart(r.Source, MccArguments.GetFarmerCropType(r, "CropType"), Arguments.GetString(r, "OtherArgs"))))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Redirect(McClient.dispatcher.GetRoot().GetChild("help").GetChild(CommandName)))
+            );
         }
 
-        private string OnFarmCommand(string cmd, string[] args)
+        public override void OnUnload()
         {
-            if (args.Length > 0)
+            McClient.dispatcher.Unregister(CommandName);
+            McClient.dispatcher.GetRoot().GetChild("help").RemoveChild(CommandName);
+        }
+
+        private int OnCommandHelp(CmdResult r, string? cmd)
         {
-                if (args[0].Equals("stop", StringComparison.OrdinalIgnoreCase))
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>   Translations.bot_farmer_desc + ": " + commandDescription
+                                   + '\n' + McClient.dispatcher.GetAllUsageString(CommandName, false),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int OnCommandStop(CmdResult r)
         {
             if (!running)
-                        return Translations.bot_farmer_already_stopped;
-
+            {
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.bot_farmer_already_stopped);
+            }
+            else
+            {
                 running = false;
-                    return Translations.bot_farmer_stopping;
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.bot_farmer_stopping);
+            }
         }
 
-                if (args[0].Equals("start", StringComparison.OrdinalIgnoreCase))
-                {
-                    if (args.Length >= 2)
+        private int OnCommandStart(CmdResult r, CropType whatToFarm, string? otherArgs)
         {
             if (running)
-                            return Translations.bot_farmer_already_running;
-
-                        if (!Enum.TryParse(args[1], true, out CropType whatToFarm))
-                            return Translations.bot_farmer_invalid_crop_type;
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.bot_farmer_already_running);
 
             int radius = 30;
 
@@ -115,15 +153,14 @@ namespace MinecraftClient.ChatBots
             allowTeleport = false;
             debugEnabled = false;
 
-                        if (args.Length >= 3)
+            if (!string.IsNullOrWhiteSpace(otherArgs))
             {
-                            for (int i = 2; i < args.Length; i++)
+                string[] args = otherArgs.ToLower().Split(' ', StringSplitOptions.TrimEntries);
+                foreach (string currentArg in args)
                 {
-                                string currentArg = args[i].Trim().ToLower();
-
                     if (!currentArg.Contains(':'))
                     {
-                                    LogToConsole("§x§1§0" + string.Format(Translations.bot_farmer_warining_invalid_parameter, currentArg));
+                        LogToConsole("§§6§1§0" + string.Format(Translations.bot_farmer_warining_invalid_parameter, currentArg));
                         continue;
                     }
 
@@ -131,7 +168,7 @@ namespace MinecraftClient.ChatBots
 
                     if (parts.Length != 2)
                     {
-                                    LogToConsole("§x§1§0" + string.Format(Translations.bot_farmer_warining_invalid_parameter, currentArg));
+                        LogToConsole("§§6§1§0" + string.Format(Translations.bot_farmer_warining_invalid_parameter, currentArg));
                         continue;
                     }
 
@@ -140,11 +177,11 @@ namespace MinecraftClient.ChatBots
                         case "r":
                         case "radius":
                             if (!int.TryParse(parts[1], NumberStyles.Any, CultureInfo.CurrentCulture, out radius))
-                                            LogToConsole("§x§1§0" + Translations.bot_farmer_invalid_radius);
+                                LogToConsole("§§6§1§0" + Translations.bot_farmer_invalid_radius);
 
                             if (radius <= 0)
                             {
-                                            LogToConsole("§x§1§0" + Translations.bot_farmer_invalid_radius);
+                                LogToConsole("§§6§1§0" + Translations.bot_farmer_invalid_radius);
                                 radius = 30;
                             }
 
@@ -157,7 +194,7 @@ namespace MinecraftClient.ChatBots
 
                             if (parts[1].Equals("true") || parts[1].Equals("1"))
                             {
-                                            LogToConsole("§x§1§0" + Translations.bot_farmer_warining_force_unsafe);
+                                LogToConsole("§§6§1§0" + Translations.bot_farmer_warining_force_unsafe);
                                 allowUnsafe = true;
                             }
                             else allowUnsafe = false;
@@ -171,7 +208,7 @@ namespace MinecraftClient.ChatBots
 
                             if (parts[1].Equals("true") || parts[1].Equals("1"))
                             {
-                                            LogToConsole("§w§1§f" + Translations.bot_farmer_warining_allow_teleport);
+                                LogToConsole("§§4§1§f" + Translations.bot_farmer_warining_allow_teleport);
                                 allowTeleport = true;
                             }
                             else allowTeleport = false;
@@ -199,12 +236,7 @@ namespace MinecraftClient.ChatBots
             running = true;
             new Thread(() => MainPorcess()).Start();
 
-                        return "";
-                    }
-                }
-            }
-
-            return Translations.bot_farmer_desc + ": " + commandDescription;
+            return r.SetAndReturn(CmdResult.Status.Done);
         }
 
         public override void AfterGameJoined()
@@ -220,9 +252,9 @@ namespace MinecraftClient.ChatBots
 
         private void MainPorcess()
         {
-            LogToConsole("§y§1§f" + Translations.bot_farmer_started);
-            LogToConsole("§y§1§f " + Translations.bot_farmer_crop_type + ": " + cropType);
-            LogToConsole("§y§1§f " + Translations.bot_farmer_radius + ": " + farmingRadius);
+            LogToConsole("§§2§1§f" + Translations.bot_farmer_started);
+            LogToConsole("§§2§1§f " + Translations.bot_farmer_crop_type + ": " + cropType);
+            LogToConsole("§§2§1§f " + Translations.bot_farmer_radius + ": " + farmingRadius);
 
             while (running)
             {
@@ -230,7 +262,7 @@ namespace MinecraftClient.ChatBots
                 if (AutoEat.Eating)
                 {
                     LogDebug("Eating...");
-                    Thread.Sleep(Config.Delay_Between_Tasks * 1000);
+                    Thread.Sleep(Delay_Between_Tasks_Millisecond);
                     continue;
                 }
 
@@ -246,7 +278,7 @@ namespace MinecraftClient.ChatBots
                         {
                             LogDebug("No seeds, trying to find some crops to break");
                             state = State.SearchingForCropsToBreak;
-                            Thread.Sleep(Config.Delay_Between_Tasks * 1000);
+                            Thread.Sleep(Delay_Between_Tasks_Millisecond);
                             continue;
                         }
 
@@ -256,7 +288,7 @@ namespace MinecraftClient.ChatBots
                         {
                             LogDebug("Could not find any farmland, trying to find some crops to break");
                             state = State.SearchingForCropsToBreak;
-                            Thread.Sleep(Config.Delay_Between_Tasks * 1000);
+                            Thread.Sleep(Delay_Between_Tasks_Millisecond);
                             continue;
                         }
 
@@ -272,7 +304,7 @@ namespace MinecraftClient.ChatBots
                                 {
                                     LogDebug("Ran out of seeds, looking for crops to break...");
                                     state = State.SearchingForCropsToBreak;
-                                    Thread.Sleep(Config.Delay_Between_Tasks * 1000);
+                                    Thread.Sleep(Delay_Between_Tasks_Millisecond);
                                     continue;
                                 }
                             }
@@ -321,7 +353,7 @@ namespace MinecraftClient.ChatBots
                         {
                             LogToConsole("No crops to break, trying to bonemeal ungrown ones");
                             state = State.BonemealingCrops;
-                            Thread.Sleep(Config.Delay_Between_Tasks * 1000);
+                            Thread.Sleep(Delay_Between_Tasks_Millisecond);
                             continue;
                         }
 
@@ -367,7 +399,7 @@ namespace MinecraftClient.ChatBots
                         if (cropType == CropType.Netherwart)
                         {
                             state = State.SearchingForFarmlandToPlant;
-                            Thread.Sleep(Config.Delay_Between_Tasks * 1000);
+                            Thread.Sleep(Delay_Between_Tasks_Millisecond);
                             continue;
                         }
 
@@ -376,7 +408,7 @@ namespace MinecraftClient.ChatBots
                         {
                             LogDebug("No bonemeal, searching for some farmland to plant seeds on");
                             state = State.SearchingForFarmlandToPlant;
-                            Thread.Sleep(Config.Delay_Between_Tasks * 1000);
+                            Thread.Sleep(Delay_Between_Tasks_Millisecond);
                             continue;
                         }
 
@@ -386,7 +418,7 @@ namespace MinecraftClient.ChatBots
                         {
                             LogDebug("No crops to bonemeal, searching for farmland to plant seeds on");
                             state = State.SearchingForFarmlandToPlant;
-                            Thread.Sleep(Config.Delay_Between_Tasks * 1000);
+                            Thread.Sleep(Delay_Between_Tasks_Millisecond);
                             continue;
                         }
 
@@ -402,7 +434,7 @@ namespace MinecraftClient.ChatBots
                                 {
                                     LogDebug("Ran out of Bone Meal, looking for farmland to plant on...");
                                     state = State.SearchingForFarmlandToPlant;
-                                    Thread.Sleep(Config.Delay_Between_Tasks * 1000);
+                                    Thread.Sleep(Delay_Between_Tasks_Millisecond);
                                     continue;
                                 }
                             }
@@ -438,8 +470,8 @@ namespace MinecraftClient.ChatBots
                         break;
                 }
 
-                LogDebug("Waiting for " + Config.Delay_Between_Tasks + " seconds for next cycle.");
-                Thread.Sleep(Config.Delay_Between_Tasks * 1000);
+                LogDebug(string.Format("Waiting for {0:0.00} seconds for next cycle.", Config.Delay_Between_Tasks));
+                Thread.Sleep(Delay_Between_Tasks_Millisecond);
             }
 
             LogToConsole(Translations.bot_farmer_stopped);
@@ -815,6 +847,7 @@ namespace MinecraftClient.ChatBots
         {
             return GetPlayerInventory().SearchItem(itemType).Length > 0;
         }
+
         private void LogDebug(object text)
         {
             if (debugEnabled)

MinecraftClient/ChatBots/FollowPlayer.cs

@@ -1,12 +1,19 @@
 using System;
 using System.Linq;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.CommandHandler.Patch;
 using MinecraftClient.Mapping;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots
 {
     public class FollowPlayer : ChatBot
     {
+        public const string CommandName = "follow";
+
         public static Configs Config = new();
 
         [TomlDoNotInlineObject]
@@ -55,58 +62,86 @@ namespace MinecraftClient.ChatBots
                 return;
             }
 
-            RegisterChatBotCommand("follow", "cmd.follow.desc", "follow <player name|stop>", OnFollowCommand);
+            McClient.dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CommandName)
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                )
+            );
+
+            McClient.dispatcher.Register(l => l.Literal(CommandName)
+                .Then(l => l.Literal("start")
+                    .Then(l => l.Argument("PlayerName", MccArguments.PlayerName())
+                        .Executes(r => OnCommandStart(r.Source, Arguments.GetString(r, "PlayerName"), takeRisk: false))
+                        .Then(l => l.Literal("-f")
+                            .Executes(r => OnCommandStart(r.Source, Arguments.GetString(r, "PlayerName"), takeRisk: true)))))
+                .Then(l => l.Literal("stop")
+                    .Executes(r => OnCommandStop(r.Source)))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Redirect(McClient.dispatcher.GetRoot().GetChild("help").GetChild(CommandName)))
+            );
         }
 
-        private string OnFollowCommand(string cmd, string[] args)
+        public override void OnUnload()
         {
-            if (args.Length > 0)
-            {
-                if (args[0].Equals("stop", StringComparison.OrdinalIgnoreCase))
-                {
-                    if (_playerToFollow == null)
-                        return Translations.cmd_follow_already_stopped;
-
-                    _playerToFollow = null;
-                    return Translations.cmd_follow_stopping;
+            McClient.dispatcher.Unregister(CommandName);
+            McClient.dispatcher.GetRoot().GetChild("help").RemoveChild(CommandName);
         }
-                else
+
+        private int OnCommandHelp(CmdResult r, string? cmd)
         {
-                    if (!IsValidName(args[0]))
-                        return Translations.cmd_follow_invalid_name;
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>   Translations.cmd_follow_desc + ": " + Translations.cmd_follow_usage
+                                   + '\n' + McClient.dispatcher.GetAllUsageString(CommandName, false),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int OnCommandStart(CmdResult r, string name, bool takeRisk)
+        {
+            if (!IsValidName(name))
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_follow_invalid_name);
 
             Entity? player = GetEntities().Values.ToList().Find(entity =>
-                        entity.Type == EntityType.Player && !string.IsNullOrEmpty(entity.Name) && entity.Name.Equals(args[0], StringComparison.OrdinalIgnoreCase));
+                entity.Type == EntityType.Player
+                && !string.IsNullOrEmpty(entity.Name)
+                && entity.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
 
             if (player == null)
-                        return Translations.cmd_follow_invalid_player;
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_follow_invalid_player);
 
             if (!CanMoveThere(player.Location))
-                        return Translations.cmd_follow_cant_reach_player;
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_follow_cant_reach_player);
 
-                    if (_playerToFollow != null && _playerToFollow.Equals(args[0], StringComparison.OrdinalIgnoreCase))
-                        return string.Format(Translations.cmd_follow_already_following, _playerToFollow);
+            if (_playerToFollow != null && _playerToFollow.Equals(name, StringComparison.OrdinalIgnoreCase))
+                return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.cmd_follow_already_following, _playerToFollow));
 
             string result;
             if (_playerToFollow != null)
                 result = string.Format(Translations.cmd_follow_switched, player.Name!);
             else
                 result = string.Format(Translations.cmd_follow_started, player.Name!);
-                    _playerToFollow = args[0].Trim().ToLower();
+            _playerToFollow = name.ToLower();
 
-                    LogToConsole(Translations.cmd_follow_note);
-
-                    if (args.Length == 2 && args[1].Equals("-f", StringComparison.OrdinalIgnoreCase))
+            if (takeRisk)
             {
                 _unsafeEnabled = true;
-                        LogToConsole(Translations.cmd_follow_unsafe_enabled);
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_follow_note + '\n' + Translations.cmd_follow_unsafe_enabled);
+            }
+            else
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_follow_note);
         }
 
-                    return result;
-                }
-            }
+        private int OnCommandStop(CmdResult r)
+        {
+            if (_playerToFollow == null)
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_follow_already_stopped);
 
-            return Translations.cmd_follow_desc + ": " + Translations.cmd_follow_usage;
+            _playerToFollow = null;
+
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_follow_stopping);
         }
 
         public override void Update()

MinecraftClient/ChatBots/HangmanGame.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Text;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots

MinecraftClient/ChatBots/Mailer.cs

@@ -3,6 +3,11 @@ using System.Collections.Generic;
 using System.Data;
 using System.IO;
 using System.Linq;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.CommandHandler.Patch;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots
@@ -12,6 +17,8 @@ namespace MinecraftClient.ChatBots
     /// </summary>
     public class Mailer : ChatBot
     {
+        public const string CommandName = "mailer";
+
         public static Configs Config = new();
 
         [TomlDoNotInlineObject]
@@ -251,7 +258,101 @@ namespace MinecraftClient.ChatBots
             mailDbFileMonitor = new FileMonitor(Path.GetDirectoryName(Config.DatabaseFile)!, Path.GetFileName(Config.DatabaseFile), FileMonitorCallback);
             ignoreListFileMonitor = new FileMonitor(Path.GetDirectoryName(Config.IgnoreListFile)!, Path.GetFileName(Config.IgnoreListFile), FileMonitorCallback);
 
-            RegisterChatBotCommand("mailer", Translations.bot_mailer_cmd, "mailer <getmails|addignored|getignored|removeignored>", ProcessInternalCommand);
+            McClient.dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CommandName)
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty)))
+            );
+
+            McClient.dispatcher.Register(l => l.Literal(CommandName)
+                .Then(l => l.Literal("getmails")
+                    .Executes(r => OnCommandGetMails()))
+                .Then(l => l.Literal("getignored")
+                    .Executes(r => OnCommandGetIgnored()))
+                .Then(l => l.Literal("addignored")
+                    .Then(l => l.Argument("username", Arguments.String())
+                        .Executes(r => OnCommandAddIgnored(Arguments.GetString(r, "username")))))
+                .Then(l => l.Literal("removeignored")
+                    .Then(l => l.Argument("username", Arguments.String())
+                        .Executes(r => OnCommandRemoveIgnored(Arguments.GetString(r, "username")))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Redirect(McClient.dispatcher.GetRoot().GetChild("help").GetChild(CommandName)))
+            );
+        }
+
+        public override void OnUnload()
+        {
+            McClient.dispatcher.Unregister(CommandName);
+            McClient.dispatcher.GetRoot().GetChild("help").RemoveChild(CommandName);
+        }
+
+        private int OnCommandHelp(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>   Translations.bot_mailer_cmd_help + ": /mailer <getmails|addignored|getignored|removeignored>"
+                                   + '\n' + McClient.dispatcher.GetAllUsageString(CommandName, false),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int OnCommandGetMails()
+        {
+            LogToConsole(string.Format(Translations.bot_mailer_cmd_getmails, string.Join("\n", mailDatabase)));
+            return 1;
+        }
+
+        private int OnCommandGetIgnored()
+        {
+            LogToConsole(string.Format(Translations.bot_mailer_cmd_getignored, string.Join("\n", ignoreList)));
+            return 1;
+        }
+
+        private int OnCommandAddIgnored(string username)
+        {
+            if (IsValidName(username))
+            {
+                username = username.ToLower();
+                lock (readWriteLock)
+                {
+                    if (!ignoreList.Contains(username))
+                    {
+                        ignoreList.Add(username);
+                        ignoreList.SaveToFile(Config.IgnoreListFile);
+                    }
+                }
+                LogToConsole(string.Format(Translations.bot_mailer_cmd_ignore_added, username));
+                return 1;
+            }
+            else
+            {
+                LogToConsole(string.Format(Translations.bot_mailer_cmd_ignore_invalid, "addignored"));
+                return 0;
+            }
+        }
+
+        private int OnCommandRemoveIgnored(string username)
+        {
+            if (IsValidName(username))
+            {
+                username = username.ToLower();
+                lock (readWriteLock)
+                {
+                    if (ignoreList.Contains(username))
+                    {
+                        ignoreList.Remove(username);
+                        ignoreList.SaveToFile(Config.IgnoreListFile);
+                    }
+                }
+                LogToConsole(string.Format(Translations.bot_mailer_cmd_ignore_removed, username));
+                return 1;
+            }
+            else
+            {
+                LogToConsole(string.Format(Translations.bot_mailer_cmd_ignore_invalid, "removeignored"));
+                return 0;
+            }
         }
 
         /// <summary>
@@ -365,57 +466,5 @@ namespace MinecraftClient.ChatBots
                 ignoreList = IgnoreList.FromFile(Config.IgnoreListFile);
             }
         }
-
-        /// <summary>
-        /// Interprets local commands.
-        /// </summary>
-        private string ProcessInternalCommand(string cmd, string[] args)
-        {
-            if (args.Length > 0)
-            {
-                string commandName = args[0].ToLower();
-                switch (commandName)
-                {
-                    case "getmails": // Sorry, I (ReinforceZwei) replaced "=" to "-" because it would affect the parsing of translation file (key=value)
-                        return string.Format(Translations.bot_mailer_cmd_getmails, string.Join("\n", mailDatabase));
-
-                    case "getignored":
-                        return string.Format(Translations.bot_mailer_cmd_getignored, string.Join("\n", ignoreList));
-
-                    case "addignored":
-                    case "removeignored":
-                        if (args.Length > 1 && IsValidName(args[1]))
-                        {
-                            string username = args[1].ToLower();
-                            if (commandName == "addignored")
-                            {
-                                lock (readWriteLock)
-                                {
-                                    if (!ignoreList.Contains(username))
-                                    {
-                                        ignoreList.Add(username);
-                                        ignoreList.SaveToFile(Config.IgnoreListFile);
-                                    }
-                                }
-                                return string.Format(Translations.bot_mailer_cmd_ignore_added, args[1]);
-                            }
-                            else
-                            {
-                                lock (readWriteLock)
-                                {
-                                    if (ignoreList.Contains(username))
-                                    {
-                                        ignoreList.Remove(username);
-                                        ignoreList.SaveToFile(Config.IgnoreListFile);
-                                    }
-                                }
-                                return string.Format(Translations.bot_mailer_cmd_ignore_removed, args[1]);
-                            }
-                        }
-                        else return string.Format(Translations.bot_mailer_cmd_ignore_invalid, commandName);
-                }
-            }
-            return Translations.bot_mailer_cmd_help + ": /help mailer";
-        }
     }
 }

MinecraftClient/ChatBots/Map.cs

@@ -1,18 +1,24 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Globalization;
 using System.IO;
 using System.Text;
 using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
 using ImageMagick;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.CommandHandler.Patch;
 using MinecraftClient.Mapping;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots
 {
     public class Map : ChatBot
     {
+        public const string CommandName = "maps";
+
         public static Configs Config = new();
 
         public struct QueuedMap
@@ -63,7 +69,7 @@ namespace MinecraftClient.ChatBots
 
         private readonly string baseDirectory = @"Rendered_Maps";
 
-        private readonly Dictionary<int, McMap> cachedMaps = new();
+        internal readonly Dictionary<int, McMap> cachedMaps = new();
 
         private readonly Queue<QueuedMap> discordQueue = new();
 
@@ -74,14 +80,79 @@ namespace MinecraftClient.ChatBots
 
             DeleteRenderedMaps();
 
-            RegisterChatBotCommand("maps", "bot.map.cmd.desc", "maps list|render <id> or maps l|r <id>", OnMapCommand);
+            McClient.dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CommandName)
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                )
+            );
+
+            McClient.dispatcher.Register(l => l.Literal(CommandName)
+                .Executes(r => OnCommandList(r.Source))
+                .Then(l => l.Literal("list")
+                    .Executes(r => OnCommandList(r.Source)))
+                .Then(l => l.Literal("render")
+                    .Then(l => l.Argument("MapID", MccArguments.MapBotMapId())
+                        .Executes(r => OnCommandRender(r.Source, Arguments.GetInteger(r, "MapID")))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Redirect(McClient.dispatcher.GetRoot().GetChild("help").GetChild(CommandName)))
+            );
         }
 
         public override void OnUnload()
         {
+            McClient.dispatcher.Unregister(CommandName);
+            McClient.dispatcher.GetRoot().GetChild("help").RemoveChild(CommandName);
             DeleteRenderedMaps();
         }
 
+        private int OnCommandHelp(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>   Translations.error_usage + ": /maps <list/render <id>>"
+                                   + '\n' + McClient.dispatcher.GetAllUsageString(CommandName, false),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int OnCommandList(CmdResult r)
+        {
+            if (cachedMaps.Count == 0)
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.bot_map_no_maps);
+
+            LogToConsole(Translations.bot_map_received);
+
+            foreach (var (key, value) in new SortedDictionary<int, McMap>(cachedMaps))
+                LogToConsole(string.Format(Translations.bot_map_list_item, key, value.LastUpdated));
+
+            return r.SetAndReturn(CmdResult.Status.Done);
+        }
+
+        private int OnCommandRender(CmdResult r, int mapId)
+        {
+            if (!cachedMaps.ContainsKey(mapId))
+                return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.bot_map_cmd_not_found, mapId));
+
+            try
+            {
+                McMap map = cachedMaps[mapId];
+                if (Config.Save_To_File)
+                    SaveToFile(map);
+
+                if (Config.Render_In_Console)
+                    RenderInConsole(map);
+
+                return r.SetAndReturn(CmdResult.Status.Done);
+            }
+            catch (Exception e)
+            {
+                LogDebugToConsole(e.StackTrace!);
+                return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.bot_map_failed_to_render, mapId));
+            }
+        }
+
         private void DeleteRenderedMaps()
         {
             if (Config.Delete_All_On_Unload)
@@ -94,56 +165,6 @@ namespace MinecraftClient.ChatBots
             }
         }
 
-        public string OnMapCommand(string command, string[] args)
-        {
-            if (args.Length == 0 || (args.Length == 1 && (args[0].ToLower().Equals("list") || args[0].ToLower().Equals("l"))))
-            {
-                if (cachedMaps.Count == 0)
-                    return Translations.bot_map_no_maps;
-
-                LogToConsole(Translations.bot_map_received);
-
-                foreach (var (key, value) in new SortedDictionary<int, McMap>(cachedMaps))
-                    LogToConsole(string.Format(Translations.bot_map_list_item, key, value.LastUpdated));
-
-                return "";
-            }
-
-            if (args.Length > 1)
-            {
-                if (args[0].ToLower().Equals("render") || args[0].ToLower().Equals("r"))
-                {
-                    if (args.Length < 2)
-                        return "maps <list/render <id>> | maps <l/r <id>>";
-
-                    if (int.TryParse(args[1], NumberStyles.Any, CultureInfo.CurrentCulture, out int mapId))
-                    {
-                        if (!cachedMaps.ContainsKey(mapId))
-                            return string.Format(Translations.bot_map_cmd_not_found, mapId);
-
-                        try
-                        {
-                            McMap map = cachedMaps[mapId];
-                            if (Config.Save_To_File)
-                                SaveToFile(map);
-
-                            if (Config.Render_In_Console)
-                                RenderInConsole(map);
-
-                            return "";
-                        }
-                        catch (Exception e)
-                        {
-                            LogDebugToConsole(e.StackTrace!);
-                            return string.Format(Translations.bot_map_failed_to_render, mapId);
-                        }
-                    }
-                    return Translations.bot_map_cmd_invalid_id;
-                }
-            }
-            return "";
-        }
-
         public override void OnMapData(int mapid, byte scale, bool trackingPosition, bool locked, List<MapIcon> icons, byte columnsUpdated, byte rowsUpdated, byte mapCoulmnX, byte mapRowZ, byte[]? colors)
         {
             if (columnsUpdated == 0 && cachedMaps.ContainsKey(mapid))
@@ -320,13 +341,11 @@ namespace MinecraftClient.ChatBots
             }
         }
 
-        private void RenderInConsole(McMap map)
+        private static void RenderInConsole(McMap map)
         {
             StringBuilder sb = new();
-
             int consoleWidth = Math.Max(Console.BufferWidth, Settings.Config.Main.Advanced.MinTerminalWidth) / 2;
             int consoleHeight = Math.Max(Console.BufferHeight, Settings.Config.Main.Advanced.MinTerminalHeight) - 1;
-
             int scaleX = (map.Width + consoleWidth - 1) / consoleWidth;
             int scaleY = (map.Height + consoleHeight - 1) / consoleHeight;
             int scale = Math.Max(scaleX, scaleY);
@@ -335,11 +354,12 @@ namespace MinecraftClient.ChatBots
 
             for (int base_y = 0; base_y < map.Height; base_y += scale)
             {
-                int last_R = -1, last_G = -1, last_B = -1;
+                string lastFg = string.Empty, lagtBg = string.Empty;
                 for (int base_x = 0; base_x < map.Width; base_x += scale)
                 {
-                    int RL = 0, GL = 0, BL = 0, RR = 0, GR = 0, BR = 0;
-                    double mid_dx = (double)(scale - 1) / 2;
+                    int RUL = 0, GUL = 0, BUL = 0, RUR = 0, GUR = 0, BUR = 0;
+                    int RDL = 0, GDL = 0, BDL = 0, RDR = 0, GDR = 0, BDR = 0;
+                    double mid = (double)(scale - 1) / 2;
                     for (int dy = 0; dy < scale; ++dy)
                     {
                         for (int dx = 0; dx < scale; ++dx)
@@ -347,40 +367,57 @@ namespace MinecraftClient.ChatBots
                             int x = Math.Min(base_x + dx, map.Width - 1);
                             int y = Math.Min(base_y + dy, map.Height - 1);
                             ColorRGBA color = MapColors.ColorByteToRGBA(map.Colors![x + y * map.Width]);
-                            if (dx <= mid_dx)
+                            if (dx <= mid)
                             {
-                                RL += color.R; GL += color.G; BL += color.B;
+                                if (dy <= mid)
+                                {
+                                    RUL += color.R; GUL += color.G; BUL += color.B;
                                 }
-                            if (dx >= mid_dx)
+                                if (dy >= mid)
                                 {
-                                RR += color.R; GR += color.G; BR += color.B;
+                                    RDL += color.R; GDL += color.G; BDL += color.B;
+                                }
+                            }
+                            if (dx >= mid)
+                            {
+                                if (dy <= mid)
+                                {
+                                    RUR += color.R; GUR += color.G; BUR += color.B;
+                                }
+                                if (dy >= mid)
+                                {
+                                    RDR += color.R; GDR += color.G; BDR += color.B;
+                                }
                             }
                         }
                     }
 
-                    int pixel_cnt = ((scale + 1) / 2) * scale;
-                    RL = (int)Math.Round((double)RL / pixel_cnt);
-                    GL = (int)Math.Round((double)GL / pixel_cnt);
-                    BL = (int)Math.Round((double)BL / pixel_cnt);
-                    RR = (int)Math.Round((double)RR / pixel_cnt);
-                    GR = (int)Math.Round((double)GR / pixel_cnt);
-                    BR = (int)Math.Round((double)BR / pixel_cnt);
+                    int pixel_cnt = ((scale + 1) / 2) * ((scale + 1) / 2);
+                    RDL = (int)Math.Round((double)RDL / pixel_cnt);
+                    GDL = (int)Math.Round((double)GDL / pixel_cnt);
+                    BDL = (int)Math.Round((double)BDL / pixel_cnt);
+                    RDR = (int)Math.Round((double)RDR / pixel_cnt);
+                    GDR = (int)Math.Round((double)GDR / pixel_cnt);
+                    BDR = (int)Math.Round((double)BDR / pixel_cnt);
 
-                    if (RL == last_R && GL == last_G && BL == last_B)
-                        sb.Append(' ');
-                    else
-                    {
-                        sb.Append(ColorHelper.GetColorEscapeCode((byte)RL, (byte)GL, (byte)BL, false)).Append(' ');
-                        last_R = RL; last_G = GL; last_B = BL;
-                    }
+                    RUL = (int)Math.Round((double)RUL / pixel_cnt);
+                    GUL = (int)Math.Round((double)GUL / pixel_cnt);
+                    BUL = (int)Math.Round((double)BUL / pixel_cnt);
+                    RUR = (int)Math.Round((double)RUR / pixel_cnt);
+                    GUR = (int)Math.Round((double)GUR / pixel_cnt);
+                    BUR = (int)Math.Round((double)BUR / pixel_cnt);
 
-                    if (RR == last_R && GR == last_G && BR == last_B)
-                        sb.Append(' ');
-                    else
-                    {
-                        sb.Append(ColorHelper.GetColorEscapeCode((byte)RR, (byte)GR, (byte)BR, false)).Append(' ');
-                        last_R = RR; last_G = GR; last_B = BR;
-                    }
+                    string colorCode = ColorHelper.GetColorEscapeCode((byte)RUL, (byte)GUL, (byte)BUL, true);
+                    if (lastFg != colorCode) { sb.Append(colorCode); lastFg = colorCode; }
+                    colorCode = ColorHelper.GetColorEscapeCode((byte)RDL, (byte)GDL, (byte)BDL, false);
+                    if (lagtBg != colorCode) { sb.Append(colorCode); lagtBg = colorCode; }
+                    sb.Append('▀');
+
+                    colorCode = ColorHelper.GetColorEscapeCode((byte)RUR, (byte)GUR, (byte)BUR, true);
+                    if (lastFg != colorCode) { sb.Append(colorCode); lastFg = colorCode; }
+                    colorCode = ColorHelper.GetColorEscapeCode((byte)RDR, (byte)GDR, (byte)BDR, false);
+                    if (lagtBg != colorCode) { sb.Append(colorCode); lagtBg = colorCode; }
+                    sb.Append('▀');
                 }
                 if (base_y >= map.Height - scale)
                     sb.Append(ColorHelper.GetResetEscapeCode());
@@ -406,7 +443,7 @@ namespace MinecraftClient.ChatBots
         public DateTime LastUpdated { get; set; }
     }
 
-    class MapColors
+    internal class MapColors
     {
         // When colors are updated in a new update, you can get them using the game code: net\minecraft\world\level\material\MaterialColor.java
         public static Dictionary<byte, byte[]> Colors = new()

MinecraftClient/ChatBots/PlayerListLogger.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Text;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots

MinecraftClient/ChatBots/RemoteControl.cs

@@ -1,4 +1,6 @@
 using System;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots
@@ -32,17 +34,9 @@ namespace MinecraftClient.ChatBots
             string command = "", sender = "";
             if (IsPrivateMessage(text, ref command, ref sender) && Settings.Config.Main.Advanced.BotOwners.Contains(sender.ToLower().Trim()))
             {
-                string? response = "";
+                CmdResult response = new();
                 PerformInternalCommand(command, ref response);
-                response = GetVerbatim(response);
-                foreach (char disallowedChar in McClient.GetDisallowedChatCharacters())
-                {
-                    response = response.Replace(disallowedChar.ToString(), String.Empty);
-                }
-                if (response.Length > 0)
-                {
-                    SendPrivateMessage(sender, response);
-                }
+                SendPrivateMessage(sender, response.ToString());
             }
             else if (Config.AutoTpaccept
                 && IsTeleportRequest(text, ref sender)

MinecraftClient/ChatBots/ReplayCapture.cs

@@ -1,6 +1,10 @@
 using System;
 using System.Collections.Generic;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.CommandHandler.Patch;
 using MinecraftClient.Protocol;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 
 namespace MinecraftClient.ChatBots
@@ -10,6 +14,8 @@ namespace MinecraftClient.ChatBots
     /// </summary>
     public class ReplayCapture : ChatBot
     {
+        public const string CommandName = "replay";
+
         public static Configs Config = new();
 
         [TomlDoNotInlineObject]
@@ -40,7 +46,74 @@ namespace MinecraftClient.ChatBots
             replay.MetaData.serverName = GetServerHost() + GetServerPort();
             backupCounter = Settings.DoubleToTick(Config.Backup_Interval);
 
-            RegisterChatBotCommand("replay", Translations.bot_replayCapture_cmd, "replay <save|stop>", Command);
+            McClient.dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CommandName)
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                )
+            );
+
+            McClient.dispatcher.Register(l => l.Literal(CommandName)
+                .Then(l => l.Literal("save")
+                    .Executes(r => OnCommandSave(r.Source)))
+                .Then(l => l.Literal("stop")
+                    .Executes(r => OnCommandStop(r.Source)))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Redirect(McClient.dispatcher.GetRoot().GetChild("help").GetChild(CommandName)))
+            );
+        }
+
+        public override void OnUnload()
+        {
+            McClient.dispatcher.Unregister(CommandName);
+            McClient.dispatcher.GetRoot().GetChild("help").RemoveChild(CommandName);
+        }
+
+        private int OnCommandHelp(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>   string.Format(Translations.general_available_cmd, "save, stop")
+                                   + '\n' + McClient.dispatcher.GetAllUsageString(CommandName, false),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int OnCommandSave(CmdResult r)
+        {
+            try
+            {
+                if (replay!.RecordRunning)
+                {
+                    replay.CreateBackupReplay(@"replay_recordings\" + replay.GetReplayDefaultName());
+                    return r.SetAndReturn(CmdResult.Status.Done, Translations.bot_replayCapture_created);
+                }
+                else
+                    return r.SetAndReturn(CmdResult.Status.Fail, Translations.bot_replayCapture_restart);
+            }
+            catch (Exception e)
+            {
+                return r.SetAndReturn(CmdResult.Status.Fail, e.Message);
+            }
+        }
+
+        private int OnCommandStop(CmdResult r)
+        {
+            try
+            {
+                if (replay!.RecordRunning)
+                {
+                    replay.OnShutDown();
+                    return r.SetAndReturn(CmdResult.Status.Done, Translations.bot_replayCapture_stopped);
+                }
+                else
+                    return r.SetAndReturn(CmdResult.Status.Fail, Translations.bot_replayCapture_restart);
+            }
+            catch (Exception e)
+            {
+                return r.SetAndReturn(CmdResult.Status.Fail, e.Message);
+            }
         }
 
         public override void OnNetworkPacket(int packetID, List<byte> packetData, bool isLogin, bool isInbound)
@@ -66,37 +139,5 @@ namespace MinecraftClient.ChatBots
             replay!.OnShutDown();
             return base.OnDisconnect(reason, message);
         }
-
-        public string Command(string cmd, string[] args)
-        {
-            try
-            {
-                if (replay!.RecordRunning)
-                {
-                    if (args.Length > 0)
-                    {
-                        switch (args[0].ToLower())
-                        {
-                            case "save":
-                                {
-                                    replay.CreateBackupReplay(@"replay_recordings\" + replay.GetReplayDefaultName());
-                                    return Translations.bot_replayCapture_created;
-                                }
-                            case "stop":
-                                {
-                                    replay.OnShutDown();
-                                    return Translations.bot_replayCapture_stopped;
-                                }
-                        }
-                    }
-                    return string.Format(Translations.general_available_cmd, "save, stop");
-                }
-                else return Translations.bot_replayCapture_restart;
-            }
-            catch (Exception e)
-            {
-                return e.Message;
-            }
-        }
     }
 }

MinecraftClient/ChatBots/Script.cs

@@ -5,6 +5,8 @@ using System.IO;
 using System.Reflection;
 using System.Text;
 using System.Threading;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.Scripting;
 
 namespace MinecraftClient.ChatBots
 {
@@ -209,11 +211,22 @@ namespace MinecraftClient.ChatBots
                                         sleepticks = ticks;
                                         break;
                                     default:
-                                        if (!PerformInternalCommand(instruction_line))
+                                        CmdResult response = new();
+                                        if (PerformInternalCommand(instruction_line, ref response))
+                                        {
+                                            if (instruction_name.ToLower() != "log")
+                                            {
+                                                LogToConsole(instruction_line);
+                                            }
+                                            if (response.status != CmdResult.Status.Done || !string.IsNullOrWhiteSpace(response.result))
+                                            {
+                                                LogToConsole(response);
+                                            }
+                                        }
+                                        else
                                         {
                                             Update(); //Unknown command : process next line immediately
                                         }
-                                        else if (instruction_name.ToLower() != "log") { LogToConsole(instruction_line); }
                                         break;
                                 }
                             }

MinecraftClient/ChatBots/ScriptScheduler.cs

@@ -1,4 +1,6 @@
 using System;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.Scripting;
 using Tomlet.Attributes;
 using static MinecraftClient.ChatBots.ScriptScheduler.Configs;
 
@@ -190,7 +192,10 @@ namespace MinecraftClient.ChatBots
                                     {
                                         task.Trigger_On_Time_Already_Triggered = true;
                                         LogDebugToConsole(string.Format(Translations.bot_scriptScheduler_running_time, task.Action));
-                                        PerformInternalCommand(task.Action);
+                                        CmdResult response = new();
+                                        PerformInternalCommand(task.Action, ref response);
+                                        if (response.status != CmdResult.Status.Done || !string.IsNullOrWhiteSpace(response.result))
+                                            LogToConsole(response);
                                     }
                                 }
                             }
@@ -208,7 +213,10 @@ namespace MinecraftClient.ChatBots
                         if (task.Trigger_On_Login || (firstlogin_done == false && task.Trigger_On_First_Login))
                         {
                             LogDebugToConsole(string.Format(Translations.bot_scriptScheduler_running_login, task.Action));
-                            PerformInternalCommand(task.Action);
+                            CmdResult response = new();
+                            PerformInternalCommand(task.Action, ref response);
+                            if (response.status != CmdResult.Status.Done || !string.IsNullOrWhiteSpace(response.result))
+                                LogToConsole(response);
                         }
                     }
 
@@ -228,7 +236,10 @@ namespace MinecraftClient.ChatBots
                             Settings.DoubleToTick(task.Trigger_On_Interval.MinTime), Settings.DoubleToTick(task.Trigger_On_Interval.MaxTime)
                         );
                         LogDebugToConsole(string.Format(Translations.bot_scriptScheduler_running_inverval, task.Action));
-                        PerformInternalCommand(task.Action);
+                        CmdResult response = new();
+                        PerformInternalCommand(task.Action, ref response);
+                        if (response.status != CmdResult.Status.Done || !string.IsNullOrWhiteSpace(response.result))
+                            LogToConsole(response);
                     }
                     else task.Trigger_On_Interval_Countdown--;
                 }

MinecraftClient/ChatBots/TelegramBridge.cs

@@ -3,6 +3,10 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.CommandHandler.Patch;
+using MinecraftClient.Scripting;
 using Telegram.Bot;
 using Telegram.Bot.Exceptions;
 using Telegram.Bot.Polling;
@@ -16,6 +20,8 @@ namespace MinecraftClient.ChatBots
 {
     public class TelegramBridge : ChatBot
     {
+        public const string CommandName = "tgbridge";
+
         private enum BridgeDirection
         {
             Both = 0,
@@ -70,17 +76,73 @@ namespace MinecraftClient.ChatBots
 
         public override void Initialize()
         {
-            RegisterChatBotCommand("tgbridge", "bot.TelegramBridge.desc", "tgbridge direction <both|mc|telegram>", OnTgCommand);
+            McClient.dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CommandName)
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                )
+            );
+
+            McClient.dispatcher.Register(l => l.Literal(CommandName)
+                .Then(l => l.Literal("direction")
+                    .Then(l => l.Literal("both")
+                        .Executes(r => OnCommandDirection(r.Source, BridgeDirection.Both)))
+                    .Then(l => l.Literal("mc")
+                        .Executes(r => OnCommandDirection(r.Source, BridgeDirection.Minecraft)))
+                    .Then(l => l.Literal("telegram")
+                        .Executes(r => OnCommandDirection(r.Source, BridgeDirection.Telegram))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => OnCommandHelp(r.Source, string.Empty))
+                    .Redirect(McClient.dispatcher.GetRoot().GetChild("help").GetChild(CommandName)))
+            );
 
             Task.Run(async () => await MainAsync());
         }
 
-        ~TelegramBridge()
+        public override void OnUnload()
         {
+            McClient.dispatcher.Unregister(CommandName);
+            McClient.dispatcher.GetRoot().GetChild("help").RemoveChild(CommandName);
             Disconnect();
         }
 
-        public override void OnUnload()
+        private int OnCommandHelp(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>   Translations.error_usage + ": /tgbridge direction <both|mc|telegram>"
+                                   + '\n' + McClient.dispatcher.GetAllUsageString(CommandName, false),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int OnCommandDirection(CmdResult r, BridgeDirection direction)
+        {
+            string bridgeName;
+            switch (direction)
+            {
+                case BridgeDirection.Both:
+                    bridgeName = Translations.bot_TelegramBridge_direction_both;
+                    bridgeDirection = BridgeDirection.Both;
+                    break;
+
+                case BridgeDirection.Minecraft:
+                    bridgeName = Translations.bot_TelegramBridge_direction_minecraft;
+                    bridgeDirection = BridgeDirection.Minecraft;
+                    break;
+
+                case BridgeDirection.Telegram:
+                    bridgeName = Translations.bot_TelegramBridge_direction_Telegram;
+                    bridgeDirection = BridgeDirection.Telegram;
+                    break;
+
+                default:
+                    goto case BridgeDirection.Both;
+            }
+            return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.bot_TelegramBridge_direction, bridgeName));
+        }
+
+        ~TelegramBridge()
         {
             Disconnect();
         }
@@ -97,7 +159,7 @@ namespace MinecraftClient.ChatBots
                 }
                 catch (Exception e)
                 {
-                    LogToConsole("§w§l§f" + Translations.bot_TelegramBridge_canceled_sending);
+                    LogToConsole("§§4§l§f" + Translations.bot_TelegramBridge_canceled_sending);
                     LogDebugToConsole(e);
                 }
 
@@ -110,47 +172,6 @@ namespace MinecraftClient.ChatBots
             return instance;
         }
 
-        private string OnTgCommand(string cmd, string[] args)
-        {
-            if (args.Length == 2)
-            {
-                if (args[0].ToLower().Equals("direction"))
-                {
-                    string direction = args[1].ToLower().Trim();
-
-                    string bridgeName;
-                    switch (direction)
-                    {
-                        case "b":
-                        case "both":
-                            bridgeName = Translations.bot_TelegramBridge_direction_both;
-                            bridgeDirection = BridgeDirection.Both;
-                            break;
-
-                        case "mc":
-                        case "minecraft":
-                            bridgeName = Translations.bot_TelegramBridge_direction_minecraft;
-                            bridgeDirection = BridgeDirection.Minecraft;
-                            break;
-
-                        case "t":
-                        case "tg":
-                        case "telegram":
-                            bridgeName = Translations.bot_TelegramBridge_direction_Telegram;
-                            bridgeDirection = BridgeDirection.Telegram;
-                            break;
-
-                        default:
-                            return Translations.bot_TelegramBridge_invalid_direction;
-                    }
-
-                    return string.Format(Translations.bot_TelegramBridge_direction, bridgeName);
-                };
-            }
-
-            return "dscbridge direction <both|mc|discord>";
-        }
-
         public override void GetText(string text)
         {
             if (!CanSendMessages())
@@ -188,7 +209,7 @@ namespace MinecraftClient.ChatBots
             }
             catch (Exception e)
             {
-                LogToConsole("§w§l§f" + Translations.bot_TelegramBridge_canceled_sending);
+                LogToConsole("§§4§l§f" + Translations.bot_TelegramBridge_canceled_sending);
                 LogDebugToConsole(e);
             }
         }
@@ -211,7 +232,7 @@ namespace MinecraftClient.ChatBots
             }
             catch (Exception e)
             {
-                LogToConsole("§w§l§f" + Translations.bot_TelegramBridge_canceled_sending);
+                LogToConsole("§§4§l§f" + Translations.bot_TelegramBridge_canceled_sending);
                 LogDebugToConsole(e);
             }
         }
@@ -233,7 +254,7 @@ namespace MinecraftClient.ChatBots
                 }
 
                 if (string.IsNullOrEmpty(Config.ChannelId.Trim()))
-                    LogToConsole("§w§l§f" + Translations.bot_TelegramBridge_missing_channel_id);
+                    LogToConsole("§§4§l§f" + Translations.bot_TelegramBridge_missing_channel_id);
 
                 botClient = new TelegramBotClient(Config.Token.Trim());
                 cancellationToken = new CancellationTokenSource();
@@ -252,12 +273,12 @@ namespace MinecraftClient.ChatBots
                 IsConnected = true;
 
                 SendMessage($"✅ {Translations.bot_TelegramBridge_connected}");
-                LogToConsole($"§y§l§f{Translations.bot_TelegramBridge_connected}");
+                LogToConsole($"§§2§l§f{Translations.bot_TelegramBridge_connected}");
 
                 if (Config.Authorized_Chat_Ids.Length == 0)
                 {
                     SendMessage($"⚠️ *{Translations.bot_TelegramBridge_missing_authorized_channels}* ⚠️");
-                    LogToConsole($"§w§l§f{Translations.bot_TelegramBridge_missing_authorized_channels}");
+                    LogToConsole($"§§4§l§f{Translations.bot_TelegramBridge_missing_authorized_channels}");
                     return;
                 }
 
@@ -265,7 +286,7 @@ namespace MinecraftClient.ChatBots
             }
             catch (Exception e)
             {
-                LogToConsole($"§w§l§f{Translations.bot_TelegramBridge_unknown_error}");
+                LogToConsole($"§§4§l§f{Translations.bot_TelegramBridge_unknown_error}");
                 LogToConsole(e);
                 return;
             }
@@ -324,9 +345,8 @@ namespace MinecraftClient.ChatBots
             {
                 var command = text[1..];
 
-                string? result = "";
+                CmdResult result = new();
                 PerformInternalCommand(command, ref result);
-                result = string.IsNullOrEmpty(result) ? "-" : result;
 
                 await botClient.SendTextMessageAsync(
                     chatId: chatId,
@@ -348,7 +368,7 @@ namespace MinecraftClient.ChatBots
                 _ => exception.ToString()
             };
 
-            LogToConsole("§w§l§f" + ErrorMessage);
+            LogToConsole("§§4§l§f" + ErrorMessage);
             return Task.CompletedTask;
         }
     }

MinecraftClient/ChatBots/TestBot.cs

@@ -1,4 +1,6 @@
-namespace MinecraftClient.ChatBots
+using MinecraftClient.Scripting;
+
+namespace MinecraftClient.ChatBots
 {
     /// <summary>
     /// Example of message receiving.

MinecraftClient/ColorHelper.cs

@@ -1,5 +1,5 @@
 using System;
-using static MinecraftClient.Settings.MainConfigHealper.MainConfig.AdvancedConfig;
+using static MinecraftClient.Settings.ConsoleConfigHealper.ConsoleConfig;
 
 namespace MinecraftClient
 {
@@ -75,14 +75,37 @@ namespace MinecraftClient
 
         public static string GetColorEscapeCode(byte R, byte G, byte B, bool foreground)
         {
-            return GetColorEscapeCode(R, G, B, foreground, Settings.Config.Main.Advanced.TerminalColorDepth);
+            return GetColorEscapeCode(R, G, B, foreground, Settings.Config.Console.General.ConsoleColorMode);
         }
 
-        public static string GetColorEscapeCode(byte R, byte G, byte B, bool foreground, TerminalColorDepthType colorDepth)
+        public static string GetColorEscapeCode(byte R, byte G, byte B, bool foreground, ConsoleColorModeType colorDepth)
         {
             switch (colorDepth)
             {
-                case TerminalColorDepthType.bit_4:
+                case ConsoleColorModeType.disable:
+                    return string.Empty;
+
+                case ConsoleColorModeType.legacy_4bit:
+                    {
+                        ColorRGBA color = new(R, G, B);
+                        int best_idx = 0;
+                        double min_distance = ColorMap4[0].Item1.Distance(color);
+                        for (int i = 1; i < ColorMap4.Length; ++i)
+                        {
+                            double distance = ColorMap4[i].Item1.Distance(color);
+                            if (distance < min_distance)
+                            {
+                                min_distance = distance;
+                                best_idx = i;
+                            }
+                        }
+                        if (foreground)
+                            return $"§{best_idx:X}";
+                        else
+                            return $"§§{best_idx:X}";
+                    }
+
+                case ConsoleColorModeType.vt100_4bit:
                     {
                         ColorRGBA color = new(R, G, B);
                         int best_idx = 0;
@@ -99,7 +122,7 @@ namespace MinecraftClient
                         return string.Format("\u001b[{0}m", ColorMap4[best_idx].Item2 - (foreground ? 10 : 0));
                     }
 
-                case TerminalColorDepthType.bit_8:
+                case ConsoleColorModeType.vt100_8bit:
                     {
                         ColorRGBA color = new(R, G, B);
                         int R_idx = (int)(R <= 95 ? Math.Round(R / 95.0) : 1 + Math.Round((R - 95.0) / 40.0));
@@ -126,7 +149,7 @@ namespace MinecraftClient
                             return string.Format("\u001B[{0};5;{1}m", (foreground ? 38 : 48), ColorMap8[best_idx].Item2);
                     }
 
-                case TerminalColorDepthType.bit_24:
+                case ConsoleColorModeType.vt100_24bit:
                     return string.Format("\u001B[{0};2;{1};{2};{3}m", (foreground ? 38 : 48), R, G, B);
 
                 default:

MinecraftClient/Command.cs

@@ -1,6 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using Brigadier.NET;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.CommandHandler.Patch;
 
 namespace MinecraftClient
 {
@@ -28,8 +31,13 @@ namespace MinecraftClient
         /// <returns>Translated command description</returns>
         public string GetCmdDescTranslated()
         {
-            string s = (string.IsNullOrEmpty(CmdUsage) || string.IsNullOrEmpty(CmdDesc)) ? "" : ": "; // If either one is empty, no colon :
-            return CmdUsage + s + CmdDesc;
+            char cmdChar = Settings.Config.Main.Advanced.InternalCmdChar.ToChar();
+
+            StringBuilder sb = new();
+            string s = (string.IsNullOrEmpty(CmdUsage) || string.IsNullOrEmpty(CmdDesc)) ? string.Empty : ": "; // If either one is empty, no colon :
+            sb.Append("§e").Append(cmdChar).Append(CmdUsage).Append("§r").Append(s).AppendLine(CmdDesc);
+            sb.Append(McClient.dispatcher.GetAllUsageString(CmdName, false));
+            return sb.ToString();
         }
 
         /// <summary>
@@ -38,18 +46,9 @@ namespace MinecraftClient
         public abstract string CmdUsage { get; }
 
         /// <summary>
-        /// Perform the command
+        /// Register the command.
         /// </summary>
-        /// <param name="command">The full command, eg: 'mycommand arg1 arg2'</param>
-        /// <param name="localVars">Local variables passed along with the command (may be null)</param>
-        /// <returns>A confirmation/error message, or "" if no message</returns>
-        public abstract string Run(McClient handler, string command, Dictionary<string, object>? localVars);
-
-        /// <summary>
-        /// Return a list of aliases for this command.
-        /// Override this method if you wish to put aliases to the command
-        /// </summary>
-        public virtual IEnumerable<string> GetCMDAliases() { return Array.Empty<string>(); }
+        public abstract void RegisterCommand(CommandDispatcher<CmdResult> dispatcher);
 
         /// <summary>
         /// Check if at least one argument has been passed to the command

MinecraftClient/CommandHandler/ArgumentType/AccountNickArgumentType.cs

@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Suggestion;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class AccountNickArgumentType : ArgumentType<string>
+    {
+        public override string Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            return reader.ReadString();
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            var accountList = Settings.Config.Main.Advanced.AccountList;
+            foreach (var account in accountList)
+                builder.Suggest(account.Key);
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/AutoCraftRecipeNameArgumentType.cs

@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Suggestion;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class AutoCraftRecipeNameArgumentType : ArgumentType<string>
+    {
+        public override string Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            return reader.ReadString();
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            var recipeList = Settings.Config.ChatBot.AutoCraft.Recipes;
+            foreach (var recipe in recipeList)
+                builder.Suggest(recipe.Name);
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/BotNameArgumentType.cs

@@ -0,0 +1,29 @@
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Suggestion;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class BotNameArgumentType : ArgumentType<string>
+    {
+        public override string Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            return reader.ReadString();
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            McClient? client = CmdResult.currentHandler;
+            if (client != null)
+            {
+                var botList = client.GetLoadedChatBots();
+                foreach (var bot in botList)
+                    builder.Suggest(bot.GetType().Name);
+            }
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/EntityTypeArgumentType.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Exceptions;
+using Brigadier.NET.Suggestion;
+using MinecraftClient.Mapping;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class EntityTypeArgumentType : ArgumentType<EntityType>
+    {
+        public override EntityType Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            string entity = reader.ReadString();
+            if (Enum.TryParse(entity, true, out EntityType entityType))
+                return entityType;
+            else
+                throw CommandSyntaxException.BuiltInExceptions.LiteralIncorrect().CreateWithContext(reader, entity);
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            foreach (EntityType result in Enum.GetValues<EntityType>())
+            {
+                string name = result.ToString();
+                string localName = Entity.GetTypeString(result);
+                bool same = true;
+                for (int i = 0, j = 0; i < name.Length; ++i, ++j)
+                {
+                    while (j < localName.Length && localName[j] == ' ')
+                        ++j;
+                    if (j >= localName.Length || name[i] != localName[j])
+                    {
+                        same = false;
+                        break;
+                    }
+                }
+                if (same)
+                    builder.Suggest(name);
+                else
+                    builder.Suggest(name, new SuggestionTooltip(localName));
+            }
+
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/FarmerCropTypeArgumentType.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Exceptions;
+using Brigadier.NET.Suggestion;
+using static MinecraftClient.ChatBots.Farmer;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class FarmerCropTypeArgumentType : ArgumentType<CropType>
+    {
+        public override CropType Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            string inputStr = reader.ReadString();
+            if (Enum.TryParse(inputStr, true, out CropType cropType))
+                return cropType;
+            else
+                throw CommandSyntaxException.BuiltInExceptions.LiteralIncorrect().CreateWithContext(reader, inputStr);
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            foreach (var result in Enum.GetNames(typeof(CropType)))
+                builder.Suggest(result);
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/HotbarSlotArgumentType.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Suggestion;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class HotbarSlotArgumentType : ArgumentType<int>
+    {
+        public override int Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            return reader.ReadInt();
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            McClient? client = CmdResult.currentHandler;
+            if (client != null)
+            {
+                Inventory.Container? inventory = client.GetInventory(0);
+                if (inventory != null)
+                {
+                    for (int i = 1; i <= 9; ++i)
+                    {
+                        if (inventory.Items.TryGetValue(i - 1 + 36, out Inventory.Item? item))
+                        {
+                            string slotStr = i.ToString();
+                            if (slotStr.StartsWith(builder.RemainingLowerCase, StringComparison.InvariantCultureIgnoreCase))
+                            {
+                                string itemDesc = item.Count == 1 ? item.GetTypeString() : string.Format("{0}x{1}", item.Count, item.GetTypeString());
+                                builder.Suggest(slotStr, new SuggestionTooltip(itemDesc));
+                            }
+                        }
+                    }
+                }
+            }
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/InventoryActionArgumentType.cs

@@ -0,0 +1,47 @@
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Exceptions;
+using Brigadier.NET.Suggestion;
+using MinecraftClient.Inventory;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class InventoryActionArgumentType : ArgumentType<WindowActionType>
+    {
+        private WindowActionType[] SupportActions = new WindowActionType[]
+        {
+            WindowActionType.LeftClick,
+            WindowActionType.RightClick,
+            WindowActionType.MiddleClick,
+            WindowActionType.ShiftClick,
+        };
+
+        public override WindowActionType Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            string inputStr = reader.ReadString().ToLower();
+            return inputStr switch
+            {
+                "left" => WindowActionType.LeftClick,
+                "leftclick" => WindowActionType.LeftClick,
+                "right" => WindowActionType.RightClick,
+                "rightclick" => WindowActionType.RightClick,
+                "mid" => WindowActionType.MiddleClick,
+                "middle" => WindowActionType.MiddleClick,
+                "middleclick" => WindowActionType.MiddleClick,
+                "shift" => WindowActionType.ShiftClick,
+                "shiftclick" => WindowActionType.ShiftClick,
+                _ => throw CommandSyntaxException.BuiltInExceptions.LiteralIncorrect().CreateWithContext(reader, inputStr)
+            };
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            foreach (var action in SupportActions)
+                builder.Suggest(action.ToString());
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/InventoryIdArgumentType.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Suggestion;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class InventoryIdArgumentType : ArgumentType<int>
+    {
+        public override int Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            return reader.ReadInt();
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            McClient? client = CmdResult.currentHandler;
+            if (client != null)
+            {
+                var invList = client.GetInventories();
+                foreach (var inv in invList)
+                {
+                    string invName = inv.Key.ToString();
+                    if (invName.StartsWith(builder.RemainingLowerCase, StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        string? invTitle = inv.Value.Title;
+                        if (!string.IsNullOrWhiteSpace(invTitle))
+                            builder.Suggest(invName, new SuggestionTooltip(invTitle));
+                        else
+                            builder.Suggest(invName);
+                    }
+                }
+            }
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/InventorySlotArgumentType.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Suggestion;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class InventorySlotArgumentType : ArgumentType<int>
+    {
+        public override int Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            return reader.ReadInt();
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            McClient? client = CmdResult.currentHandler;
+            if (client != null && context.Nodes.Count >= 2)
+            {
+                string invName = context.Nodes[1].Range.Get(builder.Input);
+                if (!int.TryParse(invName, out int invId))
+                    invId = invName switch
+                    {
+                        "creativegive" => 0,
+                        "creativedelete" => 0,
+                        "player" => 0,
+                        "container" => client.GetInventories().Keys.ToList().Max(),
+                        _ => -1,
+                    };
+
+                Inventory.Container? inventory = client.GetInventory(invId);
+                if (inventory != null)
+                {
+                    foreach ((int slot, Inventory.Item item) in inventory.Items)
+                    {
+                        if (item != null && item.Count > 0)
+                        {
+                            string slotStr = slot.ToString();
+                            if (slotStr.StartsWith(builder.RemainingLowerCase, StringComparison.InvariantCultureIgnoreCase))
+                            {
+                                string itemDesc = item.Count == 1 ? item.GetTypeString() : string.Format("{0}x{1}", item.Count, item.GetTypeString());
+                                builder.Suggest(slotStr, new SuggestionTooltip(itemDesc));
+                            }
+                        }
+                    }
+                }
+            }
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/ItemTypeArgumentType.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Exceptions;
+using Brigadier.NET.Suggestion;
+using MinecraftClient.Inventory;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class ItemTypeArgumentType : ArgumentType<ItemType>
+    {
+        public override ItemType Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            string entity = reader.ReadString();
+            if (Enum.TryParse(entity, true, out ItemType itemType))
+                return itemType;
+            else
+                throw CommandSyntaxException.BuiltInExceptions.LiteralIncorrect().CreateWithContext(reader, entity);
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            foreach (ItemType result in Enum.GetValues<ItemType>())
+            {
+                if (result == ItemType.Unknown || result == ItemType.Null)
+                    continue;
+
+                string name = result.ToString();
+                string localName = Item.GetTypeString(result);
+                bool same = true;
+                for (int i = 0, j = 0; i < name.Length; ++i, ++j)
+                {
+                    while (j < localName.Length && localName[j] == ' ')
+                        ++j;
+                    if (j >= localName.Length || name[i] != localName[j])
+                    {
+                        same = false;
+                        break;
+                    }
+                }
+                if (same)
+                    builder.Suggest(name);
+                else
+                    builder.Suggest(name, new SuggestionTooltip(localName));
+            }
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/LocationArgumentType.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Suggestion;
+using MinecraftClient.Mapping;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class LocationArgumentType : ArgumentType<Location>
+    {
+        public override Location Parse(IStringReader reader)
+        {
+            int[] status = new int[3];
+            double[] coords = new double[3];
+            for (int i = 0; i < 3; ++i)
+            {
+                reader.SkipWhitespace();
+                if (reader.Peek() == '~' || reader.Peek() == '～')
+                {
+                    status[i] = 1;
+                    reader.Next();
+                    if (reader.CanRead())
+                    {
+                        char next = reader.Peek();
+                        if (char.IsDigit(next) || next == '.' || next == '-')
+                            coords[i] = reader.ReadDouble();
+                        else if (next == '+')
+                        {
+                            reader.Next();
+                            coords[i] = reader.ReadDouble();
+                        }
+                        else coords[i] = 0;
+                    }
+                    else coords[i] = 0;
+                }
+                else
+                {
+                    status[i] = 0;
+                    coords[i] = reader.ReadDouble();
+                }
+            }
+
+            return new Location(coords[0], coords[1], coords[2], (byte)(status[0] | status[1] << 1 | status[2] << 2));
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            McClient? client = CmdResult.currentHandler;
+            string[] args = builder.Remaining.Split(' ', StringSplitOptions.TrimEntries);
+            if (args.Length == 0 || (args.Length == 1 && string.IsNullOrWhiteSpace(args[0])))
+            {
+                if (client != null)
+                {
+                    Location current = client.GetCurrentLocation();
+                    builder.Suggest(string.Format("{0:0.00}", current.X));
+                    builder.Suggest(string.Format("{0:0.00} {1:0.00}", current.X, current.Y));
+                    builder.Suggest(string.Format("{0:0.00} {1:0.00} {2:0.00}", current.X, current.Y, current.Z));
+                }
+                else
+                {
+                    builder.Suggest("~");
+                    builder.Suggest("~ ~");
+                    builder.Suggest("~ ~ ~");
+                }
+            }
+            else if (args.Length == 1 || (args.Length == 2 && string.IsNullOrWhiteSpace(args[1])))
+            {
+                string add = args.Length == 1 ? " " : string.Empty;
+                if (client != null)
+                {
+                    Location current = client.GetCurrentLocation();
+                    builder.Suggest(string.Format("{0}{2}{1:0.00}", builder.Remaining, current.Y, add));
+                    builder.Suggest(string.Format("{0}{3}{1:0.00} {2:0.00}", builder.Remaining, current.Y, current.Z, add));
+                }
+                else
+                {
+                    builder.Suggest(builder.Remaining + add + "~");
+                    builder.Suggest(builder.Remaining + add + "~ ~");
+                }
+            }
+            else if (args.Length == 2 || (args.Length == 3 && string.IsNullOrWhiteSpace(args[2])))
+            {
+                string add = args.Length == 2 ? " " : string.Empty;
+                if (client != null)
+                {
+                    Location current = client.GetCurrentLocation();
+                    builder.Suggest(string.Format("{0}{2}{1:0.00}", builder.Remaining, current.Z, add));
+                }
+                else
+                {
+                    builder.Suggest(builder.Remaining + add + "~");
+                }
+            }
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/MapBotMapIdArgumentType.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Suggestion;
+using MinecraftClient.ChatBots;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class MapBotMapIdArgumentType : ArgumentType<int>
+    {
+        public override int Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            return reader.ReadInt();
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            McClient? client = CmdResult.currentHandler;
+            if (client != null)
+            {
+                var bot = (Map?)client.GetLoadedChatBots().Find(bot => bot.GetType().Name == "Map");
+                if (bot != null)
+                {
+                    var mapList = bot.cachedMaps;
+                    foreach (var map in mapList)
+                    {
+                        string mapName = map.Key.ToString();
+                        if (mapName.StartsWith(builder.RemainingLowerCase, StringComparison.InvariantCultureIgnoreCase))
+                            builder.Suggest(mapName);
+                    }
+                }
+            }
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/PlayerNameArgumentType.cs

@@ -0,0 +1,36 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Suggestion;
+using MinecraftClient.Mapping;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class PlayerNameArgumentType : ArgumentType<string>
+    {
+        public override string Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            return reader.ReadString();
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            McClient? client = CmdResult.currentHandler;
+            if (client != null)
+            {
+                var entityList = client.GetEntities().Values.ToList();
+                foreach (var entity in entityList)
+                {
+                    if (entity.Type != EntityType.Player || string.IsNullOrWhiteSpace(entity.Name))
+                        continue;
+                    builder.Suggest(entity.Name);
+                }
+                builder.Suggest(client.GetUsername());
+            }
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/ScriptNameArgumentType.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Suggestion;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class ScriptNameArgumentType : ArgumentType<string>
+    {
+        public override string Parse(IStringReader reader)
+        {
+            string remaining = reader.Remaining;
+            reader.Cursor += reader.RemainingLength;
+            return remaining;
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            try
+            {
+                string? dir = Path.GetDirectoryName(builder.Remaining);
+                if (!string.IsNullOrEmpty(dir) && Path.Exists(dir))
+                {
+                    foreach (string fileName in Directory.GetFiles(dir, "*.cs"))
+                        builder.Suggest(fileName);
+                    foreach (string fileName in Directory.GetFiles(dir, "*.txt"))
+                        builder.Suggest(fileName);
+                }
+            }
+            catch (IOException) { }
+            catch (ArgumentException) { }
+            catch (UnauthorizedAccessException) { }
+
+            try
+            {
+                foreach (string fileName in Directory.GetFiles("." + Path.DirectorySeparatorChar, "*.cs"))
+                    builder.Suggest(fileName);
+                foreach (string fileName in Directory.GetFiles("." + Path.DirectorySeparatorChar, "*.txt"))
+                    builder.Suggest(fileName);
+            }
+            catch (IOException) { }
+            catch (ArgumentException) { }
+            catch (UnauthorizedAccessException) { }
+
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/ServerNickArgumentType.cs

@@ -0,0 +1,25 @@
+using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+using Brigadier.NET.Context;
+using Brigadier.NET.Suggestion;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class ServerNickArgumentType : ArgumentType<string>
+    {
+        public override string Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            return reader.ReadString();
+        }
+
+        public override Task<Suggestions> ListSuggestions<TSource>(CommandContext<TSource> context, SuggestionsBuilder builder)
+        {
+            var serverList = Settings.Config.Main.Advanced.ServerList;
+            foreach (var server in serverList)
+                builder.Suggest(server.Key);
+            return builder.BuildFuture();
+        }
+    }
+}

MinecraftClient/CommandHandler/ArgumentType/TupleArgumentType.cs

@@ -0,0 +1,18 @@
+using System;
+using Brigadier.NET;
+using Brigadier.NET.ArgumentTypes;
+
+namespace MinecraftClient.CommandHandler.ArgumentType
+{
+    public class TupleArgumentType : ArgumentType<Tuple<int, int>>
+    {
+        public override Tuple<int, int> Parse(IStringReader reader)
+        {
+            reader.SkipWhitespace();
+            int int1 = reader.ReadInt();
+            reader.SkipWhitespace();
+            int int2 = reader.ReadInt();
+            return new(int1, int2);
+        }
+    }
+}

MinecraftClient/CommandHandler/CmdResult.cs

@@ -0,0 +1,96 @@
+using System;
+
+namespace MinecraftClient.CommandHandler
+{
+    public class CmdResult
+    {
+        public static readonly CmdResult Empty = new();
+
+        internal static McClient? currentHandler;
+
+        public enum Status
+        {
+            NotRun = int.MinValue,
+            FailChunkNotLoad = -4,
+            FailNeedEntity = -3,
+            FailNeedInventory = -2,
+            FailNeedTerrain = -1,
+            Fail = 0,
+            Done = 1,
+        }
+
+        public CmdResult()
+        {
+            this.status = Status.NotRun;
+            this.result = null;
+        }
+
+        public Status status;
+
+        public string? result;
+
+        public int SetAndReturn(Status status)
+        {
+            this.status = status;
+            this.result = status switch
+            {
+#pragma warning disable format // @formatter:off
+                Status.NotRun             =>  null,
+                Status.FailChunkNotLoad   =>  null,
+                Status.FailNeedEntity     =>  Translations.extra_entity_required,
+                Status.FailNeedInventory  =>  Translations.extra_inventory_required,
+                Status.FailNeedTerrain    =>  Translations.extra_terrainandmovement_required,
+                Status.Fail               =>  Translations.general_fail,
+                Status.Done               =>  null,
+                _                         =>  null,
+#pragma warning restore format // @formatter:on
+            };
+            return Convert.ToInt32(this.status);
+        }
+
+        public int SetAndReturn(Status status, string? result)
+        {
+            this.status = status;
+            this.result = result;
+            return Convert.ToInt32(this.status);
+        }
+
+        public int SetAndReturn(int code, string? result)
+        {
+            this.status = (Status)Enum.ToObject(typeof(Status), code);
+            if (!Enum.IsDefined(typeof(Status), status))
+                throw new InvalidOperationException($"{code} is not a legal return value.");
+            this.result = result;
+            return code;
+        }
+
+        public int SetAndReturn(bool result)
+        {
+            this.status = result ? Status.Done : Status.Fail;
+            this.result = result ? Translations.general_done : Translations.general_fail;
+            return Convert.ToInt32(this.status);
+        }
+
+        public int SetAndReturn(string? result)
+        {
+            this.status = Status.Done;
+            this.result = result;
+            return Convert.ToInt32(this.status);
+        }
+
+        public int SetAndReturn(string? resultstr, bool result)
+        {
+            this.status = result ? Status.Done : Status.Fail;
+            this.result = resultstr;
+            return Convert.ToInt32(this.status);
+        }
+
+        public override string ToString()
+        {
+            if (result != null)
+                return result;
+            else
+                return status.ToString();
+        }
+    }
+}

MinecraftClient/CommandHandler/MccArguments.cs

@@ -0,0 +1,119 @@
+using System;
+using Brigadier.NET.Context;
+using MinecraftClient.CommandHandler.ArgumentType;
+
+namespace MinecraftClient.CommandHandler
+{
+    public static class MccArguments
+    {
+        public static LocationArgumentType Location()
+        {
+            return new LocationArgumentType();
+        }
+
+        public static Mapping.Location GetLocation<TSource>(CommandContext<TSource> context, string name)
+        {
+            return context.GetArgument<Mapping.Location>(name);
+        }
+
+        public static TupleArgumentType Tuple()
+        {
+            return new TupleArgumentType();
+        }
+
+        public static Tuple<int, int> GetTuple<TSource>(CommandContext<TSource> context, string name)
+        {
+            return context.GetArgument<Tuple<int, int>>(name);
+        }
+
+        public static EntityTypeArgumentType EntityType()
+        {
+            return new EntityTypeArgumentType();
+        }
+
+        public static Mapping.EntityType GetEntityType<TSource>(CommandContext<TSource> context, string name)
+        {
+            return context.GetArgument<Mapping.EntityType>(name);
+        }
+
+        public static ItemTypeArgumentType ItemType()
+        {
+            return new ItemTypeArgumentType();
+        }
+
+        public static Inventory.ItemType GetItemType<TSource>(CommandContext<TSource> context, string name)
+        {
+            return context.GetArgument<Inventory.ItemType>(name);
+        }
+
+        public static BotNameArgumentType BotName()
+        {
+            return new BotNameArgumentType();
+        }
+
+        public static ServerNickArgumentType ServerNick()
+        {
+            return new ServerNickArgumentType();
+        }
+
+        public static AccountNickArgumentType AccountNick()
+        {
+            return new AccountNickArgumentType();
+        }
+
+        public static InventoryIdArgumentType InventoryId()
+        {
+            return new InventoryIdArgumentType();
+        }
+
+        public static InventoryActionArgumentType InventoryAction()
+        {
+            return new InventoryActionArgumentType();
+        }
+
+        public static InventorySlotArgumentType InventorySlot()
+        {
+            return new InventorySlotArgumentType();
+        }
+
+        public static Inventory.WindowActionType GetInventoryAction<TSource>(CommandContext<TSource> context, string name)
+        {
+            return context.GetArgument<Inventory.WindowActionType>(name);
+        }
+
+        public static AutoCraftRecipeNameArgumentType AutoCraftRecipeName()
+        {
+            return new AutoCraftRecipeNameArgumentType();
+        }
+
+        public static FarmerCropTypeArgumentType FarmerCropType()
+        {
+            return new FarmerCropTypeArgumentType();
+        }
+
+        public static ChatBots.Farmer.CropType GetFarmerCropType<TSource>(CommandContext<TSource> context, string name)
+        {
+            return context.GetArgument<ChatBots.Farmer.CropType>(name);
+        }
+
+        public static PlayerNameArgumentType PlayerName()
+        {
+            return new PlayerNameArgumentType();
+        }
+
+        public static MapBotMapIdArgumentType MapBotMapId()
+        {
+            return new MapBotMapIdArgumentType();
+        }
+
+        public static HotbarSlotArgumentType HotbarSlot()
+        {
+            return new HotbarSlotArgumentType();
+        }
+
+        public static ScriptNameArgumentType ScriptName()
+        {
+            return new ScriptNameArgumentType();
+        }
+    }
+}

MinecraftClient/CommandHandler/Patch/CommandDispatcherExtensions.cs

@@ -0,0 +1,43 @@
+using System.Text;
+using Brigadier.NET;
+
+namespace MinecraftClient.CommandHandler.Patch
+{
+    public static class CommandDispatcherExtensions
+    {
+        /**
+        * This method unregisteres a previously declared command
+        *
+        * @param The name of the command to remove
+        */
+        public static void Unregister(this CommandDispatcher<CmdResult> commandDispatcher, string commandname)
+        {
+            commandDispatcher.GetRoot().RemoveChild(commandname);
+        }
+
+        public static string GetAllUsageString(this CommandDispatcher<CmdResult> commandDispatcher, string commandName, bool restricted)
+        {
+            char cmdChar = Settings.Config.Main.Advanced.InternalCmdChar.ToChar();
+            try
+            {
+                string[] usages = commandDispatcher.GetAllUsage(commandDispatcher.GetRoot().GetChild(commandName), new(), restricted);
+                StringBuilder sb = new();
+                sb.AppendLine("All Usages:");
+                foreach (var usage in usages)
+                {
+                    sb.Append(cmdChar).Append(commandName).Append(' ');
+                    if (usage.Length > 0 && usage[0] == '_')
+                        sb.AppendLine(usage.Replace("_help -> ", $"_help -> {cmdChar}help "));
+                    else
+                        sb.AppendLine(usage);
+                }
+                sb.Remove(sb.Length - 1, 1);
+                return sb.ToString();
+            }
+            catch
+            {
+                return string.Empty;
+            }
+        }
+    }
+}

MinecraftClient/CommandHandler/Patch/CommandNodeExtensions.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using System.Reflection;
+using Brigadier.NET.Tree;
+
+namespace MinecraftClient.CommandHandler.Patch
+{
+    public static class CommandNodeExtensions
+    {
+        public static void RemoveChild(this CommandNode<CmdResult> commandNode, string name)
+        {
+            var children = (IDictionary<string, CommandNode<CmdResult>>)
+                typeof(CommandNode<CmdResult>)
+                .GetField("_children", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)!
+                .GetValue(commandNode)!;
+            var literals = (IDictionary<string, LiteralCommandNode<CmdResult>>)
+                typeof(CommandNode<CmdResult>)
+                .GetField("_literals", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)!
+                .GetValue(commandNode)!;
+            var arguments = (IDictionary<string, ArgumentCommandNode<CmdResult>>)
+                typeof(CommandNode<CmdResult>)
+                .GetField("_arguments", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)!
+                .GetValue(commandNode)!;
+
+            children.Remove(name);
+            literals.Remove(name);
+        }
+    }
+}

MinecraftClient/CommandHandler/SuggestionTooltip.cs

@@ -0,0 +1,14 @@
+using Brigadier.NET;
+
+namespace MinecraftClient.CommandHandler
+{
+    internal class SuggestionTooltip : IMessage
+    {
+        public SuggestionTooltip(string tooltip)
+        {
+            String = tooltip;
+        }
+
+        public string String { get; set; }
+    }
+}

MinecraftClient/Commands/Animation.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -8,34 +10,46 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "animation <mainhand|offhand>"; } }
         public override string CmdDesc { get { return Translations.cmd_animation_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
-            {
-                string[] args = GetArgs(command);
-                if (args.Length > 0)
-                {
-                    if (args[0] == "mainhand" || args[0] == "0")
-                    {
-                        handler.DoAnimation(0);
-                        return Translations.general_done;
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Then(l => l.Literal("mainhand")
+                        .Executes(r => GetUsage(r.Source, "mainhand")))
+                    .Then(l => l.Literal("offhand")
+                        .Executes(r => GetUsage(r.Source, "offhand")))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => DoAnimation(r.Source, mainhand: true))
+                .Then(l => l.Literal("mainhand")
+                    .Executes(r => DoAnimation(r.Source, mainhand: true)))
+                .Then(l => l.Literal("offhand")
+                    .Executes(r => DoAnimation(r.Source, mainhand: false)))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
         }
-                    else if (args[0] == "offhand" || args[0] == "1")
+
+        private int GetUsage(CmdResult r, string? cmd)
         {
-                        handler.DoAnimation(1);
-                        return Translations.general_done;
-                    }
-                    else
+            return r.SetAndReturn(cmd switch
             {
-                        return GetCmdDescTranslated();
+#pragma warning disable format // @formatter:off
+                "mainhand"  =>  GetCmdDescTranslated(),
+                "offhand"   =>  GetCmdDescTranslated(),
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
         }
-                }
-                else
+
+        private static int DoAnimation(CmdResult r, bool mainhand)
         {
-                    return GetCmdDescTranslated();
-                }
-            }
-            else return GetCmdDescTranslated();
+            McClient handler = CmdResult.currentHandler!;
+            return r.SetAndReturn(handler.DoAnimation(mainhand ? 1 : 0));
         }
     }
 }

MinecraftClient/Commands/Bed.cs

@@ -1,9 +1,12 @@
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.Linq;
 using System.Threading.Tasks;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 using MinecraftClient.Mapping;
+using static MinecraftClient.CommandHandler.CmdResult;
 
 namespace MinecraftClient.Commands
 {
@@ -13,36 +16,63 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "bed leave|sleep <x> <y> <z>|sleep <radius>"; } }
         public override string CmdDesc { get { return Translations.cmd_bed_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            string[] args = GetArgs(command);
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Then(l => l.Literal("leave")
+                        .Executes(r => GetUsage(r.Source, "leave")))
+                    .Then(l => l.Literal("sleep")
+                        .Executes(r => GetUsage(r.Source, "sleep")))
+                )
+            );
 
-            if (args.Length >= 1)
-            {
-                string subcommand = args[0].ToLower().Trim();
-
-                if (subcommand.Equals("leave") || subcommand.Equals("l"))
-                {
-                    handler.SendEntityAction(Protocol.EntityActionType.LeaveBed);
-                    return Translations.cmd_bed_leaving;
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Literal("leave")
+                    .Executes(r => DoLeaveBed(r.Source)))
+                .Then(l => l.Literal("sleep")
+                    .Then(l => l.Argument("Location", MccArguments.Location())
+                        .Executes(r => DoSleepBedWithLocation(r.Source, MccArguments.GetLocation(r, "Location"))))
+                    .Then(l => l.Argument("Radius", Arguments.Double())
+                        .Executes(r => DoSleepBedWithRadius(r.Source, Arguments.GetDouble(r, "Radius")))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
         }
 
-                if (subcommand.Equals("sleep") || subcommand.Equals("s"))
+        private int GetUsage(CmdResult r, string? cmd)
         {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                "leave"     =>  GetCmdDescTranslated(),
+                "sleep"     =>  GetCmdDescTranslated(),
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private static int DoLeaveBed(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            return r.SetAndReturn(Translations.cmd_bed_leaving, handler.SendEntityAction(Protocol.EntityActionType.LeaveBed));
+        }
+
+        private static int DoSleepBedWithRadius(CmdResult r, double radius)
+        {
+            McClient handler = CmdResult.currentHandler!;
             if (!handler.GetTerrainEnabled())
-                        return Translations.error_terrain_not_enabled;
+                return r.SetAndReturn(Status.FailNeedTerrain);
 
-                    if (args.Length == 2)
-                    {
-                        if (!int.TryParse(args[1], NumberStyles.Any, CultureInfo.CurrentCulture, out int radius))
-                            return CmdUsage;
-
-                        handler.GetLogger().Info(string.Format(Translations.cmd_bed_searching, radius));
+            handler.Log.Info(string.Format(Translations.cmd_bed_searching, radius));
 
             Location current = handler.GetCurrentLocation();
             Location bedLocation = current;
 
-                        Material[] bedMaterialList = new Material[]{
+            Material[] bedMaterialList = new Material[]
+            {
                 Material.BlackBed,
                 Material.BlueBed,
                 Material.BrownBed,
@@ -75,12 +105,13 @@ namespace MinecraftClient.Commands
             }
 
             if (!found)
-                            return Translations.cmd_bed_bed_not_found;
+                return r.SetAndReturn(Status.Fail, Translations.cmd_bed_bed_not_found);
 
             handler.Log.Info(string.Format(Translations.cmd_bed_found_a_bed_at, bedLocation.X, bedLocation.Y, bedLocation.Z));
 
             if (!Movement.CheckChunkLoading(handler.GetWorld(), current, bedLocation))
-                            return string.Format(Translations.cmd_move_chunk_not_loaded, bedLocation.X, bedLocation.Y, bedLocation.Z);
+                return r.SetAndReturn(Status.FailChunkNotLoad,
+                    string.Format(Translations.cmd_move_chunk_not_loaded, bedLocation.X, bedLocation.Y, bedLocation.Z));
 
             if (handler.MoveTo(bedLocation))
             {
@@ -117,34 +148,34 @@ namespace MinecraftClient.Commands
                     ));
                 });
 
-                            return "";
+                return r.SetAndReturn(Status.Done);
             }
-
-                        return Translations.cmd_bed_cant_reach_safely;
-                    }
-
-                    if (args.Length >= 3)
+            else
             {
-                        Location block = Location.Parse(handler.GetCurrentLocation(), args[1], args[2], args[3]).ToFloor();
+                return r.SetAndReturn(Status.Fail, Translations.cmd_bed_cant_reach_safely);
+            }
+        }
+
+        private static int DoSleepBedWithLocation(CmdResult r, Location block)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
+            block.ToAbsolute(handler.GetCurrentLocation());
             Location blockCenter = block.ToCenter();
 
             if (!handler.GetWorld().GetBlock(block).Type.IsBed())
-                            return string.Format(Translations.cmd_bed_not_a_bed, blockCenter.X, blockCenter.Y, blockCenter.Z);
+                return r.SetAndReturn(Status.Fail,
+                    string.Format(Translations.cmd_bed_not_a_bed, blockCenter.X, blockCenter.Y, blockCenter.Z));
 
-                        bool res = handler.PlaceBlock(block, Direction.Down);
-
-                        return string.Format(
+            return r.SetAndReturn(Status.Done, string.Format(
                 Translations.cmd_bed_trying_to_use,
                 blockCenter.X,
                 blockCenter.Y,
                 blockCenter.Z,
-                            res ? Translations.cmd_bed_in : Translations.cmd_bed_not_in
-                        );
-                    }
-                }
-            }
-
-            return CmdUsage;
+                handler.PlaceBlock(block, Direction.Down) ? Translations.cmd_bed_in : Translations.cmd_bed_not_in
+            ));
         }
     }
 }

MinecraftClient/Commands/BlockInfo.cs

@@ -1,6 +1,9 @@
-using System.Collections.Generic;
-using System.Text;
+using System.Text;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 using MinecraftClient.Mapping;
+using static MinecraftClient.CommandHandler.CmdResult;
 
 namespace MinecraftClient.Commands
 {
@@ -10,36 +13,67 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "blockinfo <x> <y> <z> [-s]"; } }
         public override string CmdDesc { get { return Translations.cmd_blockinfo_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Then(l => l.Literal("-s")
+                        .Executes(r => GetUsage(r.Source, "-s")))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => LogBlockInfo(r.Source, null, false))
+                .Then(l => l.Literal("-s")
+                    .Executes(r => LogBlockInfo(r.Source, null, true)))
+                .Then(l => l.Argument("Location", MccArguments.Location())
+                    .Executes(r => LogBlockInfo(r.Source, MccArguments.GetLocation(r, "Location"), false))
+                    .Then(l => l.Literal("-s")
+                        .Executes(r => LogBlockInfo(r.Source, MccArguments.GetLocation(r, "Location"), true))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                "-s"        =>  GetCmdDescTranslated(),
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private static int LogBlockInfo(CmdResult r, Location? targetBlock, bool reportSurrounding)
+        {
+            McClient handler = CmdResult.currentHandler!;
             if (!handler.GetTerrainEnabled())
-                return Translations.error_terrain_not_enabled;
+                return r.SetAndReturn(Status.FailNeedTerrain);
 
-            string[] args = GetArgs(command);
+            if (targetBlock.HasValue)
+                targetBlock.Value.ToAbsolute(handler.GetCurrentLocation());
+            else
+                targetBlock = handler.GetCurrentLocation();
 
-            if (args.Length < 3)
-                return CmdUsage;
-
-            bool reportSurrounding = args.Length >= 4 && args[3].Equals("-s", System.StringComparison.OrdinalIgnoreCase);
-
-            Location current = handler.GetCurrentLocation();
-            Location targetBlockLocation = Location.Parse(current, args[0], args[1], args[2]);
-
-            Block block = handler.GetWorld().GetBlock(targetBlockLocation);
+            Block block = handler.GetWorld().GetBlock(targetBlock.Value);
 
             handler.Log.Info($"{Translations.cmd_blockinfo_BlockType}: {block.GetTypeString()}");
-
             if (reportSurrounding)
             {
                 StringBuilder sb = new();
                 sb.AppendLine($"{Translations.cmd_blockinfo_BlocksAround}:");
 
-                Block blockXPositive = handler.GetWorld().GetBlock(new Location(targetBlockLocation.X + 1, targetBlockLocation.Y, targetBlockLocation.Z));
-                Block blockXNegative = handler.GetWorld().GetBlock(new Location(targetBlockLocation.X - 1, targetBlockLocation.Y, targetBlockLocation.Z));
-                Block blockYPositive = handler.GetWorld().GetBlock(new Location(targetBlockLocation.X, targetBlockLocation.Y + 1, targetBlockLocation.Z));
-                Block blockYNegative = handler.GetWorld().GetBlock(new Location(targetBlockLocation.X, targetBlockLocation.Y - 1, targetBlockLocation.Z));
-                Block blockZPositive = handler.GetWorld().GetBlock(new Location(targetBlockLocation.X, targetBlockLocation.Y, targetBlockLocation.Z + 1));
-                Block blockZNegative = handler.GetWorld().GetBlock(new Location(targetBlockLocation.X, targetBlockLocation.Y, targetBlockLocation.Z - 1));
+                double X = targetBlock.Value.X, Y = targetBlock.Value.Y, Z = targetBlock.Value.Z;
+                Block blockXPositive = handler.GetWorld().GetBlock(new Location(X + 1, Y, Z));
+                Block blockXNegative = handler.GetWorld().GetBlock(new Location(X - 1, Y, Z));
+                Block blockYPositive = handler.GetWorld().GetBlock(new Location(X, Y + 1, Z));
+                Block blockYNegative = handler.GetWorld().GetBlock(new Location(X, Y - 1, Z));
+                Block blockZPositive = handler.GetWorld().GetBlock(new Location(X, Y, Z + 1));
+                Block blockZNegative = handler.GetWorld().GetBlock(new Location(X, Y, Z - 1));
 
                 sb.AppendLine($"[X {Translations.cmd_blockinfo_Positive}] {Translations.cmd_blockinfo_BlockType}: {blockXPositive.GetTypeString()}");
                 sb.AppendLine($"[X {Translations.cmd_blockinfo_Negative}] {Translations.cmd_blockinfo_BlockType}: {blockXNegative.GetTypeString()}");
@@ -56,9 +90,7 @@ namespace MinecraftClient.Commands
 
                 handler.Log.Info(sb.ToString());
             }
-
-
-            return "";
+            return r.SetAndReturn(Status.Done);
         }
     }
 }

MinecraftClient/Commands/Bots.cs

@@ -1,6 +1,9 @@
 using System;
-using System.Collections.Generic;
 using System.Text;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.Scripting;
 
 namespace MinecraftClient.Commands
 {
@@ -10,65 +13,85 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "bots [list|unload <bot name|all>]"; } }
         public override string CmdDesc { get { return Translations.cmd_bots_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
-            {
-                string[] args = GetArgs(command);
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Then(l => l.Literal("list")
+                        .Executes(r => GetUsage(r.Source, "list")))
+                    .Then(l => l.Literal("unload")
+                        .Executes(r => GetUsage(r.Source, "unload")))
+                )
+            );
 
-                if (args.Length == 1)
-                {
-                    if (args[0].Equals("list", StringComparison.OrdinalIgnoreCase))
-                    {
-                        StringBuilder sb = new();
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => DoListBot(r.Source))
+                .Then(l => l.Literal("list")
+                    .Executes(r => DoListBot(r.Source)))
+                .Then(l => l.Literal("unload")
+                    .Then(l => l.Argument("BotName", MccArguments.BotName())
+                        .Executes(r => DoUnloadBot(r.Source, Arguments.GetString(r, "BotName")))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
 
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                "list"      =>  GetCmdDescTranslated(),
+                "unload"    =>  GetCmdDescTranslated(),
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoListBot(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
             int length = handler.GetLoadedChatBots().Count;
-
             if (length == 0)
-                            return Translations.cmd_bots_noloaded;
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_bots_noloaded);
 
+            StringBuilder sb = new();
             for (int i = 0; i < length; i++)
             {
                 sb.Append(handler.GetLoadedChatBots()[i].GetType().Name);
-
                 if (i != length - 1)
                     sb.Append(" ,");
-
             }
 
-                        return Translations.cmd_bots_list + ": " + sb.ToString();
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_bots_list + ": " + sb.ToString());
         }
 
-                }
-                else if (args.Length == 2)
+        private int DoUnloadBot(CmdResult r, string botName)
         {
-                    if (args[0].Equals("unload", StringComparison.OrdinalIgnoreCase))
-                    {
-                        string botName = args[1].Trim();
-
+            McClient handler = CmdResult.currentHandler!;
             if (botName.ToLower().Equals("all", StringComparison.OrdinalIgnoreCase))
             {
                 if (handler.GetLoadedChatBots().Count == 0)
-                                return Translations.cmd_bots_noloaded;
-
+                    return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_bots_noloaded);
+                else
+                {
                     handler.UnloadAllBots();
-                            return Translations.cmd_bots_unloaded_all;
+                    return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_bots_unloaded_all);
+                }
             }
             else
             {
                 ChatBot? bot = handler.GetLoadedChatBots().Find(bot => bot.GetType().Name.ToLower() == botName.ToLower());
-
                 if (bot == null)
-                                return string.Format(Translations.cmd_bots_notfound, botName);
-
+                    return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.cmd_bots_notfound, botName));
+                else
+                {
                     handler.BotUnLoad(bot);
-                            return string.Format(Translations.cmd_bots_unloaded, botName);
+                    return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.cmd_bots_unloaded, botName));
                 }
             }
         }
     }
-
-            return GetCmdDescTranslated();
-        }
-    }
 }

MinecraftClient/Commands/ChangeSlot.cs

@@ -1,5 +1,7 @@
-using System;
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using static MinecraftClient.CommandHandler.CmdResult;
 
 namespace MinecraftClient.Commands
 {
@@ -9,35 +11,43 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "changeslot <1-9>"; } }
         public override string CmdDesc { get { return Translations.cmd_changeSlot_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (!handler.GetInventoryEnabled())
-                return Translations.extra_inventory_required;
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
 
-            if (HasArg(command))
-            {
-                short slot;
-                try
-                {
-                    slot = Convert.ToInt16(GetArg(command));
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Argument("Slot", MccArguments.HotbarSlot())
+                    .Executes(r => DoChangeSlot(r.Source, Arguments.GetInteger(r, "Slot"))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
         }
-                catch (FormatException)
+
+        private int GetUsage(CmdResult r, string? cmd)
         {
-                    return Translations.cmd_changeSlot_nan;
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
         }
-                if (slot >= 1 && slot <= 9)
+
+        private int DoChangeSlot(CmdResult r, int slot)
         {
-                    if (handler.ChangeSlot(slot -= 1))
-                    {
-                        return string.Format(Translations.cmd_changeSlot_changed, (slot += 1));
-                    }
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetInventoryEnabled())
+                return r.SetAndReturn(Status.FailNeedInventory);
+
+            if (handler.ChangeSlot((short)(slot - 1)))
+                return r.SetAndReturn(Status.Done, string.Format(Translations.cmd_changeSlot_changed, slot));
             else
-                    {
-                        return Translations.cmd_changeSlot_fail;
-                    }
-                }
-            }
-            return GetCmdDescTranslated();
+                return r.SetAndReturn(Status.Fail, Translations.cmd_changeSlot_fail);
         }
     }
 }

MinecraftClient/Commands/Chunk.cs

@@ -1,8 +1,10 @@
 using System;
-using System.Collections.Generic;
-using System.Globalization;
 using System.Text;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 using MinecraftClient.Mapping;
+using static MinecraftClient.CommandHandler.CmdResult;
 
 namespace MinecraftClient.Commands
 {
@@ -12,20 +14,77 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "chunk status [chunkX chunkZ|locationX locationY locationZ]"; } }
         public override string CmdDesc { get { return Translations.cmd_chunk_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Then(l => l.Literal("status")
+                        .Executes(r => GetUsage(r.Source, "status")))
+                    .Then(l => l.Literal("_setloading")
+                        .Executes(r => GetUsage(r.Source, "_setloading")))
+                    .Then(l => l.Literal("_setloaded")
+                        .Executes(r => GetUsage(r.Source, "_setloaded")))
+                    .Then(l => l.Literal("_delete")
+                        .Executes(r => GetUsage(r.Source, "_delete")))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Literal("status")
+                    .Executes(r => LogChunkStatus(r.Source))
+                    .Then(l => l.Argument("Location", MccArguments.Location())
+                        .Executes(r => LogChunkStatus(r.Source, pos: MccArguments.GetLocation(r, "Location"))))
+                    .Then(l => l.Argument("Chunk", MccArguments.Tuple())
+                        .Executes(r => LogChunkStatus(r.Source, markedChunkPos: MccArguments.GetTuple(r, "Chunk")))))
+                .Then(l => l.Literal("_setloading")
+                    .Then(l => l.Argument("Location", MccArguments.Location())
+                        .Executes(r => DebugSetLoading(r.Source, pos: MccArguments.GetLocation(r, "Location"))))
+                    .Then(l => l.Argument("Chunk", MccArguments.Tuple())
+                        .Executes(r => DebugSetLoading(r.Source, markedChunkPos: MccArguments.GetTuple(r, "Chunk")))))
+                .Then(l => l.Literal("_setloaded")
+                    .Then(l => l.Argument("Location", MccArguments.Location())
+                        .Executes(r => DebugSetLoaded(r.Source, pos: MccArguments.GetLocation(r, "Location"))))
+                    .Then(l => l.Argument("Chunk", MccArguments.Tuple())
+                        .Executes(r => DebugSetLoaded(r.Source, markedChunkPos: MccArguments.GetTuple(r, "Chunk")))))
+                .Then(l => l.Literal("_delete")
+                    .Then(l => l.Argument("Location", MccArguments.Location())
+                        .Executes(r => DebugDelete(r.Source, pos: MccArguments.GetLocation(r, "Location"))))
+                    .Then(l => l.Argument("Chunk", MccArguments.Tuple())
+                        .Executes(r => DebugDelete(r.Source, markedChunkPos: MccArguments.GetTuple(r, "Chunk")))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
         {
-                string[] args = GetArgs(command);
-                if (args.Length > 0)
+            return r.SetAndReturn(cmd switch
             {
-                    if (args[0] == "status")
+#pragma warning disable format // @formatter:off
+                "status"       =>  GetCmdDescTranslated(),
+                "_setloading"  =>  GetCmdDescTranslated(),
+                "_setloaded"   => GetCmdDescTranslated(),
+                "_delete"      => GetCmdDescTranslated(),
+                _              =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private static int LogChunkStatus(CmdResult r, Location? pos = null, Tuple<int, int>? markedChunkPos = null)
         {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
             World world = handler.GetWorld();
             Location current = handler.GetCurrentLocation();
+            if (pos.HasValue)
+                pos.Value.ToAbsolute(current);
 
-                        Tuple<int, int>? markedChunkPos = ParseChunkPos(args);
-                        (int markChunkX, int markChunkZ) = markedChunkPos ?? (new(current.ChunkX, current.ChunkZ));
+            (int markChunkX, int markChunkZ) = markedChunkPos ??
+                (pos.HasValue ? new(pos.Value.ChunkX, pos.Value.ChunkZ) : new(current.ChunkX, current.ChunkZ));
 
             StringBuilder sb = new();
 
@@ -36,12 +95,9 @@ namespace MinecraftClient.Commands
             if (markedChunkPos != null)
             {
                 sb.Append(Translations.cmd_chunk_marked);
-                            if (args.Length == 1 + 3)
-                                sb.Append(String.Format("X:{0:0.00} Y:{1:0.00} Z:{2:0.00}, ", 
-                                    double.Parse(args[1], NumberStyles.Any, CultureInfo.CurrentCulture), 
-                                    double.Parse(args[2], NumberStyles.Any, CultureInfo.CurrentCulture), 
-                                    double.Parse(args[3], NumberStyles.Any, CultureInfo.CurrentCulture)));
-                            sb.AppendLine(string.Format(Translations.cmd_chunk_chunk_pos, markChunkX, markChunkZ));;
+                if (pos.HasValue)
+                    sb.Append(string.Format("X:{0:0.00} Y:{1:0.00} Z:{2:0.00}, ", pos.Value.X, pos.Value.Y, pos.Value.Z));
+                sb.AppendLine(string.Format(Translations.cmd_chunk_chunk_pos, markChunkX, markChunkZ)); ;
             }
 
             int consoleHeight = Math.Max(Math.Max(Console.BufferHeight, Settings.Config.Main.Advanced.MinTerminalHeight) - 2, 25);
@@ -127,7 +183,7 @@ namespace MinecraftClient.Commands
             if (markedChunkPos != null &&
                 (((Math.Max(bottomMost, markChunkZ) - Math.Min(topMost, markChunkZ) + 1) > consoleHeight) ||
                 ((Math.Max(rightMost, markChunkX) - Math.Min(leftMost, markChunkX) + 1) > consoleWidth)))
-                            sb.AppendLine("§x§0" + Translations.cmd_chunk_outside);
+                sb.AppendLine(Translations.cmd_chunk_outside);
             else
             {
                 topMost = Math.Min(topMost, markChunkZ);
@@ -147,9 +203,9 @@ namespace MinecraftClient.Commands
                 for (int x = leftMost; x <= rightMost; ++x)
                 {
                     if (z == current.ChunkZ && x == current.ChunkX)
-                                    sb.Append("§z");           // Player Location: background gray
+                        sb.Append("§§7");           // Player Location: background gray
                     else if (z == markChunkZ && x == markChunkX)
-                                    sb.Append("§w");           // Marked chunk: background red
+                        sb.Append("§§4");           // Marked chunk: background red
 
                     ChunkColumn? chunkColumn = world[x, z];
                     if (chunkColumn == null)
@@ -160,100 +216,70 @@ namespace MinecraftClient.Commands
                         sb.Append(chunkStatusStr[1]);
 
                     if ((z == current.ChunkZ && x == current.ChunkX) || (z == markChunkZ && x == markChunkX))
-                                    sb.Append("§r");           // Reset background color
+                        sb.Append("§§r");           // Reset background color
                 }
                 sb.Append('\n');
             }
 
-                        sb.AppendLine(string.Format(Translations.cmd_chunk_icon, "§z  §r", "§w  §r", chunkStatusStr[0], chunkStatusStr[1], chunkStatusStr[2]));
-                        return sb.ToString();
-                    }
-                    else if (args[0] == "setloading") // For debugging
-                    {
-                        Tuple<int, int>? chunkPos = ParseChunkPos(args);
-                        if (chunkPos != null)
-                        {
-                            handler.Log.Info("§x§0" + Translations.cmd_chunk_for_debug);
-                            World world = handler.GetWorld();
-                            (int chunkX, int chunkZ) = chunkPos;
-                            ChunkColumn? chunkColumn = world[chunkX, chunkZ];
-                            if (chunkColumn != null)
-                                chunkColumn.FullyLoaded = false;
-                            return (chunkColumn == null) ? "Fail: chunk dosen't exist!" :
-                                String.Format("Successfully marked chunk ({0}, {1}) as loading.", chunkX, chunkZ);
-                        }
-                        else
-                            return GetCmdDescTranslated();
-                    }
-                    else if (args[0] == "setloaded") // For debugging
-                    {
-                        Tuple<int, int>? chunkPos = ParseChunkPos(args);
-                        if (chunkPos != null)
-                        {
-                            handler.Log.Info("§x§0" + Translations.cmd_chunk_for_debug);
-                            World world = handler.GetWorld();
-                            (int chunkX, int chunkZ) = chunkPos;
-                            ChunkColumn? chunkColumn = world[chunkX, chunkZ];
-                            if (chunkColumn != null)
-                                chunkColumn.FullyLoaded = true;
-                            return (chunkColumn == null) ? "Fail: chunk dosen't exist!" :
-                                String.Format("Successfully marked chunk ({0}, {1}) as loaded.", chunkX, chunkZ);
-                        }
-                        else
-                            return GetCmdDescTranslated();
-                    }
-                    else if (args[0] == "delete") // For debugging
-                    {
-                        Tuple<int, int>? chunkPos = ParseChunkPos(args);
-                        if (chunkPos != null)
-                        {
-                            handler.Log.Info("§x§0" + Translations.cmd_chunk_for_debug);
-                            World world = handler.GetWorld();
-                            (int chunkX, int chunkZ) = chunkPos;
-                            world[chunkX, chunkZ] = null;
-                            return String.Format("Successfully deleted chunk ({0}, {1}).", chunkX, chunkZ);
-                        }
-                        else
-                            return GetCmdDescTranslated();
-                    }
-                    else
-                        return GetCmdDescTranslated();
-                }
-                else
-                    return GetCmdDescTranslated();
-            }
-            else
-                return GetCmdDescTranslated();
+            sb.Append(string.Format(Translations.cmd_chunk_icon, "§§7  §§r", "§§4  §§r", chunkStatusStr[0], chunkStatusStr[1], chunkStatusStr[2]));
+            handler.Log.Info(sb.ToString());
+
+            return r.SetAndReturn(Status.Done);
         }
 
-        private static Tuple<int, int>? ParseChunkPos(string[] args)
+        private static int DebugSetLoading(CmdResult r, Location? pos = null, Tuple<int, int>? markedChunkPos = null)
         {
-            try
-            {
-                int chunkX, chunkZ;
-                if (args.Length == 1 + 3)
-                {
-                    Location pos = new(
-                        double.Parse(args[1], NumberStyles.Any, CultureInfo.CurrentCulture), 
-                        double.Parse(args[2], NumberStyles.Any, CultureInfo.CurrentCulture), 
-                        double.Parse(args[3], NumberStyles.Any, CultureInfo.CurrentCulture)
-                        );
-                    chunkX = pos.ChunkX;
-                    chunkZ = pos.ChunkZ;
-                }
-                else if (args.Length == 1 + 2)
-                {
-                    chunkX = int.Parse(args[1], NumberStyles.Any, CultureInfo.CurrentCulture);
-                    chunkZ = int.Parse(args[2], NumberStyles.Any, CultureInfo.CurrentCulture);
-                }
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
+            if (pos.HasValue)
+                pos.Value.ToAbsolute(handler.GetCurrentLocation());
+            handler.Log.Info(Translations.cmd_chunk_for_debug);
+            (int chunkX, int chunkZ) = markedChunkPos ?? new(pos!.Value.ChunkX, pos!.Value.ChunkZ);
+            ChunkColumn? chunkColumn = handler.GetWorld()[chunkX, chunkZ];
+            if (chunkColumn != null)
+                chunkColumn.FullyLoaded = false;
+
+            if (chunkColumn == null)
+                return r.SetAndReturn(Status.Fail, "Fail: chunk dosen't exist!");
             else
-                    return null;
-                return new(chunkX, chunkZ);
+                return r.SetAndReturn(Status.Done, string.Format("Successfully marked chunk ({0}, {1}) as loading.", chunkX, chunkZ));
         }
-            catch (FormatException)
+
+        private static int DebugSetLoaded(CmdResult r, Location? pos = null, Tuple<int, int>? markedChunkPos = null)
         {
-                return null;
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
+            if (pos.HasValue)
+                pos.Value.ToAbsolute(handler.GetCurrentLocation());
+            handler.Log.Info(Translations.cmd_chunk_for_debug);
+            (int chunkX, int chunkZ) = markedChunkPos ?? new(pos!.Value.ChunkX, pos!.Value.ChunkZ);
+            ChunkColumn? chunkColumn = handler.GetWorld()[chunkX, chunkZ];
+            if (chunkColumn != null)
+                chunkColumn.FullyLoaded = false;
+
+            if (chunkColumn == null)
+                return r.SetAndReturn(Status.Fail, "Fail: chunk dosen't exist!");
+            else
+                return r.SetAndReturn(Status.Done, string.Format("Successfully marked chunk ({0}, {1}) as loaded.", chunkX, chunkZ));
         }
+
+        private static int DebugDelete(CmdResult r, Location? pos = null, Tuple<int, int>? markedChunkPos = null)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
+            if (pos.HasValue)
+                pos.Value.ToAbsolute(handler.GetCurrentLocation());
+            handler.Log.Info(Translations.cmd_chunk_for_debug);
+            (int chunkX, int chunkZ) = markedChunkPos ?? new(pos!.Value.ChunkX, pos!.Value.ChunkZ);
+            handler.GetWorld()[chunkX, chunkZ] = null;
+
+            return r.SetAndReturn(Status.Done, string.Format("Successfully deleted chunk ({0}, {1}).", chunkX, chunkZ));
         }
     }
 }

MinecraftClient/Commands/Connect.cs

@@ -1,4 +1,7 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using static MinecraftClient.CommandHandler.CmdResult;
 
 namespace MinecraftClient.Commands
 {
@@ -8,27 +11,66 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "connect <server> [account]"; } }
         public override string CmdDesc { get { return Translations.cmd_connect_desc; } }
 
-        public override string Run(McClient? handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Argument("ServerNick", MccArguments.ServerNick())
+                    .Executes(r => DoConnect(r.Source, Arguments.GetString(r, "ServerNick"), string.Empty))
+                    .Then(l => l.Argument("AccountNick", MccArguments.AccountNick())
+                        .Executes(r => DoConnect(r.Source, Arguments.GetString(r, "ServerNick"), Arguments.GetString(r, "AccountNick")))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoConnect(CmdResult r, string server, string account)
+        {
+            if (!string.IsNullOrWhiteSpace(account) && !Settings.Config.Main.Advanced.SetAccount(account))
+                return r.SetAndReturn(Status.Fail, string.Format(Translations.cmd_connect_unknown, account));
+
+            if (Settings.Config.Main.SetServerIP(new Settings.MainConfigHealper.MainConfig.ServerInfoConfig(server), true))
+            {
+                Program.Restart(keepAccountAndServerSettings: true);
+                return r.SetAndReturn(Status.Done);
+            }
+            else
+            {
+                return r.SetAndReturn(Status.Fail, string.Format(Translations.cmd_connect_invalid_ip, server));
+            }
+        }
+
+        internal static string DoConnect(string command)
         {
             string[] args = GetArgs(command);
-                if (args.Length > 1)
-                {
-                    if (!Settings.Config.Main.Advanced.SetAccount(args[1]))
-                    {
+            if (args.Length > 1 && !Settings.Config.Main.Advanced.SetAccount(args[1]))
                 return string.Format(Translations.cmd_connect_unknown, args[1]);
-                    }
-                }
 
             if (Settings.Config.Main.SetServerIP(new Settings.MainConfigHealper.MainConfig.ServerInfoConfig(args[0]), true))
             {
                 Program.Restart(keepAccountAndServerSettings: true);
-                    return "";
+                return string.Empty;
             }
-                else return string.Format(Translations.cmd_connect_invalid_ip, args[0]);
+            else
+            {
+                return string.Format(Translations.cmd_connect_invalid_ip, args[0]);
             }
-            else return GetCmdDescTranslated();
         }
     }
 }

MinecraftClient/Commands/Debug.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -8,16 +10,47 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "debug [on|off]"; } }
         public override string CmdDesc { get { return Translations.cmd_debug_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
-                Settings.Config.Logging.DebugMessages = (GetArg(command).ToLower() == "on");
-            else
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => SetDebugMode(r.Source, true))
+                .Then(l => l.Literal("on")
+                    .Executes(r => SetDebugMode(r.Source, false, true)))
+                .Then(l => l.Literal("off")
+                    .Executes(r => SetDebugMode(r.Source, false, false)))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int SetDebugMode(CmdResult r, bool flip, bool mode = false)
+        {
+            if (flip)
                 Settings.Config.Logging.DebugMessages = !Settings.Config.Logging.DebugMessages;
-            if (Settings.Config.Logging.DebugMessages)
-                return Translations.cmd_debug_state_on;
             else
-                return Translations.cmd_debug_state_off;
+                Settings.Config.Logging.DebugMessages = mode;
+
+            if (Settings.Config.Logging.DebugMessages)
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_debug_state_on);
+            else
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_debug_state_off);
         }
     }
 }

MinecraftClient/Commands/Dig.cs

@@ -1,6 +1,9 @@
 using System;
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 using MinecraftClient.Mapping;
+using static MinecraftClient.CommandHandler.CmdResult;
 
 namespace MinecraftClient.Commands
 {
@@ -10,49 +13,75 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "dig <x> <y> <z>"; } }
         public override string CmdDesc { get { return Translations.cmd_dig_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (!handler.GetTerrainEnabled())
-                return Translations.extra_terrainandmovement_required;
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
 
-            string[] args = GetArgs(command);
-            if (args.Length == 0)
-            {
-                (bool hasBlock, Location blockLoc, Block block) = RaycastHelper.RaycastBlock(handler, 4.5, false);
-                if (!hasBlock)
-                    return Translations.cmd_dig_too_far;
-                else if (block.Type == Material.Air)
-                    return Translations.cmd_dig_no_block;
-                else if (handler.DigBlock(blockLoc, lookAtBlock: false))
-                    return string.Format(Translations.cmd_dig_dig, blockLoc.X, blockLoc.Y, blockLoc.Z, block.GetTypeString());
-                else
-                    return Translations.cmd_dig_fail;
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => DigLookAt(r.Source))
+                .Then(l => l.Argument("Duration", Arguments.Double())
+                    .Executes(r => DigLookAt(r.Source, Arguments.GetDouble(r, "Duration"))))
+                .Then(l => l.Argument("Location", MccArguments.Location())
+                    .Executes(r => DigAt(r.Source, MccArguments.GetLocation(r, "Location")))
+                    .Then(l => l.Argument("Duration", Arguments.Double())
+                        .Executes(r => DigAt(r.Source, MccArguments.GetLocation(r, "Location"), Arguments.GetDouble(r, "Duration")))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
         }
-            else if (args.Length == 3)
+
+        private int GetUsage(CmdResult r, string? cmd)
         {
-                try
+            return r.SetAndReturn(cmd switch
             {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DigAt(CmdResult r, Location blockToBreak, double duration = 0)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
             Location current = handler.GetCurrentLocation();
-                    Location blockToBreak = Location.Parse(current.ToFloor(), args[0], args[1], args[2]);
+            blockToBreak = blockToBreak.ToAbsolute(current);
             if (blockToBreak.DistanceSquared(current.EyesLocation()) > 25)
-                        return Translations.cmd_dig_too_far;
+                return r.SetAndReturn(Status.Fail, Translations.cmd_dig_too_far);
             Block block = handler.GetWorld().GetBlock(blockToBreak);
             if (block.Type == Material.Air)
-                        return Translations.cmd_dig_no_block;
-                    else if (handler.DigBlock(blockToBreak))
+                return r.SetAndReturn(Status.Fail, Translations.cmd_dig_no_block);
+            else if (handler.DigBlock(blockToBreak, duration: duration))
             {
                 blockToBreak = blockToBreak.ToCenter();
-                        return string.Format(Translations.cmd_dig_dig, blockToBreak.X, blockToBreak.Y, blockToBreak.Z, block.GetTypeString());
+                return r.SetAndReturn(Status.Done, string.Format(Translations.cmd_dig_dig, blockToBreak.X, blockToBreak.Y, blockToBreak.Z, block.GetTypeString()));
             }
             else
-                        return Translations.cmd_dig_fail;
+                return r.SetAndReturn(Status.Fail, Translations.cmd_dig_fail);
         }
-                catch (FormatException) { return GetCmdDescTranslated(); }
-            }
-            else
+
+        private int DigLookAt(CmdResult r, double duration = 0)
         {
-                return GetCmdDescTranslated();
-            }
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
+            (bool hasBlock, Location blockLoc, Block block) = RaycastHelper.RaycastBlock(handler, 4.5, false);
+            if (!hasBlock)
+                return r.SetAndReturn(Status.Fail, Translations.cmd_dig_too_far);
+            else if (block.Type == Material.Air)
+                return r.SetAndReturn(Status.Fail, Translations.cmd_dig_no_block);
+            else if (handler.DigBlock(blockLoc, lookAtBlock: false, duration: duration))
+                return r.SetAndReturn(Status.Done, string.Format(Translations.cmd_dig_dig, blockLoc.X, blockLoc.Y, blockLoc.Z, block.GetTypeString()));
+            else
+                return r.SetAndReturn(Status.Fail, Translations.cmd_dig_fail);
         }
     }
 }

MinecraftClient/Commands/DropItem.cs

@@ -1,27 +1,52 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 using MinecraftClient.Inventory;
+using static MinecraftClient.CommandHandler.CmdResult;
 
 namespace MinecraftClient.Commands
 {
     class DropItem : Command
     {
         public override string CmdName { get { return "dropitem"; } }
-        public override string CmdUsage { get { return "/dropitem <itemtype>"; } }
+        public override string CmdUsage { get { return "dropitem <itemtype>"; } }
         public override string CmdDesc { get { return Translations.cmd_dropItem_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (!handler.GetInventoryEnabled())
-            {
-                return Translations.extra_inventory_required;
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Argument("ItemType", MccArguments.ItemType())
+                    .Executes(r => DoDropItem(r.Source, MccArguments.GetItemType(r, "ItemType"))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
         }
-            if (HasArg(command))
+
+        private int GetUsage(CmdResult r, string? cmd)
         {
-                string arg = GetArg(command);
-                if (Enum.TryParse(arg, true, out ItemType itemType))
+            return r.SetAndReturn(cmd switch
             {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoDropItem(CmdResult r, ItemType itemType)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetInventoryEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
             int inventoryId;
             var inventories = handler.GetInventories();
             List<int> availableIds = inventories.Keys.ToList();
@@ -33,20 +58,9 @@ namespace MinecraftClient.Commands
             var p = inventories[inventoryId];
             int[] targetItems = p.SearchItem(itemType);
             foreach (int slot in targetItems)
-                    {
                 handler.DoWindowAction(inventoryId, slot, WindowActionType.DropItemStack);
-                    }
-                    return string.Format(Translations.cmd_dropItem_dropped, itemType.ToString(), inventoryId);
-                }
-                else
-                {
-                    return string.Format(Translations.cmd_dropItem_unknown_item, arg);
-                }
-            }
-            else
-            {
-                return CmdUsage;
-            }
+
+            return r.SetAndReturn(Status.Done, string.Format(Translations.cmd_dropItem_dropped, Item.GetTypeString(itemType), inventoryId));
         }
     }
 }

MinecraftClient/Commands/Enchant.cs

@@ -1,5 +1,7 @@
-using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 using MinecraftClient.Inventory;
 
 namespace MinecraftClient.Commands
@@ -10,26 +12,49 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "enchant <top|middle|bottom>"; } }
         public override string CmdDesc { get { return Translations.cmd_enchant_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (!handler.GetInventoryEnabled())
-                return Translations.error_inventoryhandling_not_enabled;
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Then(l => l.Literal("top")
+                        .Executes(r => GetUsage(r.Source, "top")))
+                    .Then(l => l.Literal("middle")
+                        .Executes(r => GetUsage(r.Source, "middle")))
+                    .Then(l => l.Literal("bottom")
+                        .Executes(r => GetUsage(r.Source, "bottom")))
+                )
+            );
 
-            if (HasArg(command))
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Literal("top")
+                    .Executes(r => DoEnchant(r.Source, slotId: 0)))
+                .Then(l => l.Literal("middle")
+                    .Executes(r => DoEnchant(r.Source, slotId: 1)))
+                .Then(l => l.Literal("bottom")
+                    .Executes(r => DoEnchant(r.Source, slotId: 2)))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
         {
-                string slot = GetArg(command).ToLower().Trim();
-
-                int slotId = slot switch
+            return r.SetAndReturn(cmd switch
             {
-                    "top" => 0,
-                    "middle" => 1,
-                    "bottom" => 2,
-                    _ => -1
-                };
-
-                if (slotId == -1)
-                    return Translations.cmd_enchant_invalid_slot;
+#pragma warning disable format // @formatter:off
+                "top"       =>  GetCmdDescTranslated(),
+                "middle"    =>  GetCmdDescTranslated(),
+                "bottom"    =>  GetCmdDescTranslated(),
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
 
+        private int DoEnchant(CmdResult r, int slotId)
+        {
+            McClient handler = CmdResult.currentHandler!;
             Container? enchantingTable = null;
 
             foreach (var (id, container) in handler.GetInventories())
@@ -42,28 +67,25 @@ namespace MinecraftClient.Commands
             }
 
             if (enchantingTable == null)
-                    return Translations.cmd_enchant_enchanting_table_not_opened;
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_enchant_enchanting_table_not_opened);
 
             int[] emptySlots = enchantingTable.GetEmpytSlots();
 
             if (emptySlots.Contains(0))
-                    return Translations.cmd_enchant_enchanting_no_item;
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_enchant_enchanting_no_item);
 
             if (emptySlots.Contains(1))
-                    return Translations.cmd_enchant_enchanting_no_lapis;
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_enchant_enchanting_no_lapis);
 
             Item lapisSlot = enchantingTable.Items[1];
 
-                if (lapisSlot.Type != ItemType.LapisLazuli)
-                    return Translations.cmd_enchant_enchanting_no_lapis;
-
-                if (lapisSlot.Count < 3)
-                    return Translations.cmd_enchant_enchanting_no_lapis;
+            if (lapisSlot.Type != ItemType.LapisLazuli || lapisSlot.Count < 3)
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_enchant_enchanting_no_lapis);
 
             EnchantmentData? enchantment = handler.GetLastEnchantments();
 
             if (enchantment == null)
-                    return Translations.cmd_enchant_no_enchantments;
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_enchant_no_enchantments);
 
             short requiredLevel = slotId switch
             {
@@ -74,12 +96,14 @@ namespace MinecraftClient.Commands
             };
 
             if (handler.GetLevel() < requiredLevel)
-                    return string.Format(Translations.cmd_enchant_no_levels, handler.GetLevel(), requiredLevel);
-
-                return handler.ClickContainerButton(enchantingTable.ID, slotId) ? Translations.cmd_enchant_clicked : Translations.cmd_enchant_not_clicked;
+                return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.cmd_enchant_no_levels, handler.GetLevel(), requiredLevel));
+            else
+            {
+                if (handler.ClickContainerButton(enchantingTable.ID, slotId))
+                    return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_enchant_clicked);
+                else
+                    return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_enchant_not_clicked);
             }
-
-            return GetCmdDescTranslated();
         }
     }
 }

MinecraftClient/Commands/Entitycmd.cs

@@ -1,10 +1,13 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
 using System.Text;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 using MinecraftClient.Inventory;
 using MinecraftClient.Mapping;
+using static MinecraftClient.CommandHandler.CmdResult;
 
 namespace MinecraftClient.Commands
 {
@@ -14,6 +17,187 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "entity [near] <id|entitytype> <attack|use>"; } }
         public override string CmdDesc { get { return string.Empty; } }
 
+        private enum ActionType { Attack, Use, List };
+
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
+        {
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Then(l => l.Literal("near")
+                        .Executes(r => GetUsage(r.Source, "near")))
+                    .Then(l => l.Literal("attack")
+                        .Executes(r => GetUsage(r.Source, "attack")))
+                    .Then(l => l.Literal("use")
+                        .Executes(r => GetUsage(r.Source, "use")))
+                    .Then(l => l.Literal("list")
+                        .Executes(r => GetUsage(r.Source, "list")))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => GetFullEntityList(r.Source))
+                .Then(l => l.Literal("near")
+                    .Executes(r => GetClosetEntityList(r.Source))
+                    .Then(l => l.Argument("EntityID", Arguments.Integer())
+                        .Executes(r => OperateWithId(r.Source, Arguments.GetInteger(r, "EntityID"), ActionType.List))
+                        .Then(l => l.Literal("attack")
+                            .Executes(r => OperateWithId(r.Source, Arguments.GetInteger(r, "EntityID"), ActionType.Attack)))
+                        .Then(l => l.Literal("use")
+                            .Executes(r => OperateWithId(r.Source, Arguments.GetInteger(r, "EntityID"), ActionType.Use)))
+                        .Then(l => l.Literal("list")
+                            .Executes(r => OperateWithId(r.Source, Arguments.GetInteger(r, "EntityID"), ActionType.List))))
+                    .Then(l => l.Argument("EntityType", MccArguments.EntityType())
+                        .Executes(r => OperateWithType(r.Source, true, MccArguments.GetEntityType(r, "EntityType"), ActionType.List))
+                        .Then(l => l.Literal("attack")
+                            .Executes(r => OperateWithType(r.Source, near: true, MccArguments.GetEntityType(r, "EntityType"), ActionType.Attack)))
+                        .Then(l => l.Literal("use")
+                            .Executes(r => OperateWithType(r.Source, near: true, MccArguments.GetEntityType(r, "EntityType"), ActionType.Use)))
+                        .Then(l => l.Literal("list")
+                            .Executes(r => OperateWithType(r.Source, near: true, MccArguments.GetEntityType(r, "EntityType"), ActionType.List)))))
+                .Then(l => l.Argument("EntityID", Arguments.Integer())
+                    .Executes(r => OperateWithId(r.Source, Arguments.GetInteger(r, "EntityID"), ActionType.List))
+                    .Then(l => l.Literal("attack")
+                        .Executes(r => OperateWithId(r.Source, Arguments.GetInteger(r, "EntityID"), ActionType.Attack)))
+                    .Then(l => l.Literal("use")
+                        .Executes(r => OperateWithId(r.Source, Arguments.GetInteger(r, "EntityID"), ActionType.Use)))
+                    .Then(l => l.Literal("list")
+                        .Executes(r => OperateWithId(r.Source, Arguments.GetInteger(r, "EntityID"), ActionType.List))))
+                .Then(l => l.Argument("EntityType", MccArguments.EntityType())
+                    .Executes(r => OperateWithType(r.Source, true, MccArguments.GetEntityType(r, "EntityType"), ActionType.List))
+                    .Then(l => l.Literal("attack")
+                        .Executes(r => OperateWithType(r.Source, near: false, MccArguments.GetEntityType(r, "EntityType"), ActionType.Attack)))
+                    .Then(l => l.Literal("use")
+                        .Executes(r => OperateWithType(r.Source, near: false, MccArguments.GetEntityType(r, "EntityType"), ActionType.Use)))
+                    .Then(l => l.Literal("list")
+                        .Executes(r => OperateWithType(r.Source, near: false, MccArguments.GetEntityType(r, "EntityType"), ActionType.List))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                "near"      =>  GetCmdDescTranslated(),
+                "attack"    =>  GetCmdDescTranslated(),
+                "use"       =>  GetCmdDescTranslated(),
+                "list"      =>  GetCmdDescTranslated(),
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int GetFullEntityList(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetEntityHandlingEnabled())
+                return r.SetAndReturn(Status.FailNeedEntity);
+
+            Dictionary<int, Entity> entities = handler.GetEntities();
+            StringBuilder response = new();
+            response.AppendLine(Translations.cmd_entityCmd_entities);
+            foreach (var entity2 in entities)
+                response.AppendLine(GetEntityInfoShort(entity2.Value));
+            response.Append(GetCmdDescTranslated());
+            handler.Log.Info(response.ToString());
+
+            return r.SetAndReturn(Status.Done);
+        }
+
+        private int GetClosetEntityList(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetEntityHandlingEnabled())
+                return r.SetAndReturn(Status.FailNeedEntity);
+
+            if (TryGetClosetEntity(handler.GetEntities(), handler.GetCurrentLocation(), null, out Entity? closest))
+            {
+                handler.Log.Info(GetEntityInfoDetailed(handler, closest));
+                return r.SetAndReturn(Status.Done);
+            }
+            else
+                return r.SetAndReturn(Status.Fail, Translations.cmd_entityCmd_not_found);
+        }
+
+        private int OperateWithId(CmdResult r, int entityID, ActionType action)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetEntityHandlingEnabled())
+                return r.SetAndReturn(Status.FailNeedEntity);
+
+            if (handler.GetEntities().TryGetValue(entityID, out Entity? entity))
+            {
+                handler.Log.Info(InteractionWithEntity(handler, entity, action));
+                return r.SetAndReturn(Status.Done);
+            }
+            else
+                return r.SetAndReturn(Status.Fail, Translations.cmd_entityCmd_not_found);
+        }
+
+        private int OperateWithType(CmdResult r, bool near, EntityType entityType, ActionType action)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetEntityHandlingEnabled())
+                return r.SetAndReturn(Status.FailNeedEntity);
+
+            if (near)
+            {
+                if (TryGetClosetEntity(handler.GetEntities(), handler.GetCurrentLocation(), entityType, out Entity? closest))
+                {
+                    handler.Log.Info(InteractionWithEntity(handler, closest, action));
+                    return r.SetAndReturn(Status.Done);
+                }
+                else
+                    return r.SetAndReturn(Status.Fail, Translations.cmd_entityCmd_not_found);
+            }
+            else
+            {
+                if (action == ActionType.Attack || action == ActionType.Use)
+                {
+                    string actionst = Translations.cmd_entityCmd_attacked;
+                    int actioncount = 0;
+                    foreach (var entity2 in handler.GetEntities())
+                    {
+                        if (entity2.Value.Type == entityType)
+                        {
+                            if (action == ActionType.Attack)
+                            {
+                                handler.InteractEntity(entity2.Key, InteractType.Attack);
+                                actionst = Translations.cmd_entityCmd_attacked;
+                            }
+                            else if (action == ActionType.Use)
+                            {
+                                handler.InteractEntity(entity2.Key, InteractType.Interact);
+                                actionst = Translations.cmd_entityCmd_used;
+                            }
+                            actioncount++;
+                        }
+                    }
+                    handler.Log.Info(actioncount + " " + actionst);
+                    return r.SetAndReturn(Status.Done);
+                }
+                else
+                {
+                    StringBuilder response = new();
+                    response.AppendLine(Translations.cmd_entityCmd_entities);
+                    foreach (var entity2 in handler.GetEntities())
+                    {
+                        if (entity2.Value.Type == entityType)
+                        {
+                            response.AppendLine(GetEntityInfoShort(entity2.Value));
+                        }
+                    }
+                    response.Append(GetCmdDescTranslated());
+                    handler.Log.Info(response.ToString());
+                    return r.SetAndReturn(Status.Done);
+                }
+            }
+        }
+
         private static string GetEntityInfoShort(Entity entity)
         {
             int id = entity.ID;
@@ -122,122 +306,21 @@ namespace MinecraftClient.Commands
             return find;
         }
 
-        private static string InteractionWithEntity(McClient handler, Entity entity, string action)
+        private static string InteractionWithEntity(McClient handler, Entity entity, ActionType action)
         {
             switch (action)
             {
-                case "attack":
+                case ActionType.Attack:
                     handler.InteractEntity(entity.ID, InteractType.Attack);
                     return Translations.cmd_entityCmd_attacked;
-                case "use":
+                case ActionType.Use:
                     handler.InteractEntity(entity.ID, InteractType.Interact);
                     return Translations.cmd_entityCmd_used;
-                default:
+                case ActionType.List:
                     return GetEntityInfoDetailed(handler, entity);
+                default:
+                    goto case ActionType.List;
             }
         }
-
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
-        {
-            if (handler.GetEntityHandlingEnabled())
-            {
-                string[] args = GetArgs(command);
-                if (args.Length > 0)
-                {
-                    if (int.TryParse(args[0], NumberStyles.Any, CultureInfo.CurrentCulture, out int entityID))
-                    {
-                        if (handler.GetEntities().TryGetValue(entityID, out Entity? entity))
-                            return InteractionWithEntity(handler, entity, args.Length > 1 ? args[1].ToLower() : "list");
-                        else
-                            return Translations.cmd_entityCmd_not_found;
-                    }
-                    else if (Enum.TryParse(args[0], true, out EntityType interacttype))
-                    {
-                        string action = args.Length > 1
-                        ? args[1].ToLower()
-                        : "list";
-                        if (action == "attack" || action == "use")
-                        {
-                            string actionst = Translations.cmd_entityCmd_attacked;
-                            int actioncount = 0;
-                            foreach (var entity2 in handler.GetEntities())
-                            {
-                                if (entity2.Value.Type == interacttype)
-                                {
-                                    if (action == "attack")
-                                    {
-                                        handler.InteractEntity(entity2.Key, InteractType.Attack);
-                                        actionst = Translations.cmd_entityCmd_attacked;
-                                        actioncount++;
-                                    }
-                                    else if (action == "use")
-                                    {
-                                        handler.InteractEntity(entity2.Key, InteractType.Interact);
-                                        actionst = Translations.cmd_entityCmd_used;
-                                        actioncount++;
-                                    }
-                                    else return GetCmdDescTranslated();
-                                }
-                            }
-                            return actioncount + " " + actionst;
-                        }
-
-                        StringBuilder response = new();
-                        response.AppendLine(Translations.cmd_entityCmd_entities);
-                        foreach (var entity2 in handler.GetEntities())
-                        {
-                            if (entity2.Value.Type == interacttype)
-                            {
-                                response.AppendLine(GetEntityInfoShort(entity2.Value));
-                            }
-                        }
-                        response.Append(GetCmdDescTranslated());
-                        return response.ToString();
-                    }
-                    else if (args[0] == "near")
-                    {
-                        if (args.Length > 1)
-                        {
-                            if (Enum.TryParse(args[1], true, out EntityType entityType))
-                            {
-                                if (TryGetClosetEntity(handler.GetEntities(), handler.GetCurrentLocation(), entityType, out Entity? closest))
-                                    return InteractionWithEntity(handler, closest, args.Length > 2 ? args[2].ToLower() : "list");
-                                else
-                                    return Translations.cmd_entityCmd_not_found;
-                            }
-                            else if (int.TryParse(args[1], NumberStyles.Any, CultureInfo.CurrentCulture, out int entityID2))
-                            {
-                                if (handler.GetEntities().TryGetValue(entityID2, out Entity? entity))
-                                    return InteractionWithEntity(handler, entity, args.Length > 1 ? args[1].ToLower() : "list");
-                                else
-                                    return Translations.cmd_entityCmd_not_found;
-                            }
-                            else return GetCmdDescTranslated();
-                        }
-                        else
-                        {
-                            if (TryGetClosetEntity(handler.GetEntities(), handler.GetCurrentLocation(), null, out Entity? closest))
-                                return GetEntityInfoDetailed(handler, closest);
-                            else
-                                return Translations.cmd_entityCmd_not_found;
-                        }
-                    }
-                    else return GetCmdDescTranslated();
-                }
-                else
-                {
-                    Dictionary<int, Entity> entities = handler.GetEntities();
-                    StringBuilder response = new();
-                    response.AppendLine(Translations.cmd_entityCmd_entities);
-                    foreach (var entity2 in entities)
-                    {
-                        response.AppendLine(GetEntityInfoShort(entity2.Value));
-                    }
-                    response.Append(GetCmdDescTranslated());
-                    return response.ToString();
-                }
-            }
-            else return Translations.extra_entity_required;
-        }
     }
 }

MinecraftClient/Commands/ExecIf.cs

@@ -1,36 +1,46 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
 using DynamicExpresso;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
     class ExecIf : Command
     {
         public override string CmdName { get { return "execif"; } }
-        public override string CmdUsage { get { return "execif <condition/expression> ---> <command>"; } }
+        public override string CmdUsage { get { return "execif \"<condition/expression>\" \"<command>\""; } }
         public override string CmdDesc { get { return Translations.cmd_execif_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Argument("Condition", Arguments.String())
+                    .Then(l => l.Argument("Command", Arguments.String())
+                        .Executes(r => HandleCommand(r.Source, Arguments.GetString(r, "Condition"), Arguments.GetString(r, "Command")))))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
         {
-                string commandsString = GetArg(command);
-
-                if (!commandsString.Contains("--->"))
-                    return GetCmdDescTranslated();
-
-                string[] parts = commandsString.Split("--->", StringSplitOptions.TrimEntries)
-                    .ToList()
-                    .ConvertAll(command => command.Trim())
-                    .ToArray();
-
-                if (parts.Length == 0)
-                    return GetCmdDescTranslated();
-
-                string expressionText = parts[0];
-                string resultCommand = parts[1];
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
 
+        private int HandleCommand(CmdResult r, string expressionText, string resultCommand)
+        {
+            McClient handler = CmdResult.currentHandler!;
             try
             {
                 var interpreter = new Interpreter();
@@ -65,30 +75,21 @@ namespace MinecraftClient.Commands
 
                 if (shouldExec)
                 {
-                        string? output = "";
+                    CmdResult output = new();
                     handler.PerformInternalCommand(resultCommand, ref output);
 
-                        if (string.IsNullOrEmpty(output))
-                            handler.Log.Debug(string.Format(Translations.cmd_execif_executed_no_output, expressionText, resultCommand));
-                        else
-                            handler.Log.Debug(string.Format(Translations.cmd_execif_executed, expressionText, resultCommand, output));
-
-                        return "";
+                    return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.cmd_execif_executed, expressionText, resultCommand, output));
+                }
+                else
+                {
+                    return r.SetAndReturn(CmdResult.Status.Done);
                 }
-
-                    return "";
             }
             catch (Exception e)
             {
-                    handler.Log.Error(string.Format(Translations.cmd_execif_error_occured, command));
                 handler.Log.Error(string.Format(Translations.cmd_execif_error, e.Message));
-                    return "";
+                return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.cmd_execif_error_occured, expressionText + " ---> " + resultCommand));
             }
         }
-
-            return GetCmdDescTranslated();
-        }
-
-
     }
 }

MinecraftClient/Commands/ExecMulti.cs

@@ -1,6 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -10,14 +13,35 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "execmulti <command 1> -> <command2> -> <command 3> -> ..."; } }
         public override string CmdDesc { get { return Translations.cmd_execmulti_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
-            {
-                string commandsString = GetArg(command);
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
 
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Argument("Commands", Arguments.GreedyString())
+                    .Executes(r => HandleCommand(r.Source, Arguments.GetString(r, "Commands"))))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int HandleCommand(CmdResult r, string commandsString)
+        {
+            McClient handler = CmdResult.currentHandler!;
             if (commandsString.Contains("execmulti", StringComparison.OrdinalIgnoreCase) || commandsString.Contains("execif", StringComparison.OrdinalIgnoreCase))
-                    return Translations.cmd_execmulti_prevent;
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_execmulti_prevent);
 
             IEnumerable<string> commands = commandsString.Split("->", StringSplitOptions.TrimEntries)
                 .ToList()
@@ -25,23 +49,12 @@ namespace MinecraftClient.Commands
 
             foreach (string cmd in commands)
             {
-                    string? output = "";
+                CmdResult output = new();
                 handler.PerformInternalCommand(cmd, ref output);
-
-                    string log = string.Format(
-                        Translations.cmd_execmulti_executed, cmd,
-                        string.IsNullOrEmpty(output) ? Translations.cmd_execmulti_no_result : string.Format(Translations.cmd_execmulti_result, output));
-
-                    if (output != null && output.Contains("unknown command", StringComparison.OrdinalIgnoreCase))
-                        handler.Log.Error(log);
-                    else
-                        handler.Log.Info(log);
+                handler.Log.Info(string.Format(Translations.cmd_execmulti_executed, cmd, string.Format(Translations.cmd_execmulti_result, output)));
             }
 
-                return "";
-            }
-
-            return GetCmdDescTranslated();
+            return r.SetAndReturn(CmdResult.Status.Done);
         }
     }
 }

MinecraftClient/Commands/Exit.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -8,15 +10,49 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "exit"; } }
         public override string CmdDesc { get { return Translations.cmd_exit_desc; } }
 
-        public override string Run(McClient? handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            Program.Exit();
-            return "";
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            var exit = dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => DoExit(r.Source, 0))
+                .Then(l => l.Argument("ExitCode", Arguments.Integer())
+                    .Executes(r => DoExit(r.Source, Arguments.GetInteger(r, "ExitCode"))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+
+            dispatcher.Register(l => l.Literal("quit")
+                .Executes(r => DoExit(r.Source, 0))
+                .Redirect(exit)
+            );
         }
 
-        public override IEnumerable<string> GetCMDAliases()
+        private int GetUsage(CmdResult r, string? cmd)
         {
-            return new string[] { "quit" };
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoExit(CmdResult r, int code = 0)
+        {
+            Program.Exit(code);
+            return r.SetAndReturn(CmdResult.Status.Done);
+        }
+
+        internal static string DoExit(string command)
+        {
+            Program.Exit();
+            return string.Empty;
         }
     }
 }

MinecraftClient/Commands/Health.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -8,9 +10,36 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "health"; } }
         public override string CmdDesc { get { return Translations.cmd_health_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            return string.Format(Translations.cmd_health_response, handler.GetHealth(), handler.GetSaturation(), handler.GetLevel(), handler.GetTotalExperience());
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => LogHealth(r.Source))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int LogHealth(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.cmd_health_response, handler.GetHealth(), handler.GetSaturation(), handler.GetLevel(), handler.GetTotalExperience()));
         }
     }
 }

MinecraftClient/Commands/Help.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Text;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+
+namespace MinecraftClient.Commands
+{
+    internal class Help : Command
+    {
+        public override string CmdName => throw new NotImplementedException();
+        public override string CmdDesc => throw new NotImplementedException();
+        public override string CmdUsage => throw new NotImplementedException();
+
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
+        {
+            dispatcher.Register(l =>
+                l.Literal("help")
+                    .Executes(r => LogHelp(r.Source, dispatcher))
+            );
+        }
+
+        private int LogHelp(CmdResult r, CommandDispatcher<CmdResult> dispatcher)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            var usage = dispatcher.GetSmartUsage(dispatcher.GetRoot(), CmdResult.Empty);
+            StringBuilder sb = new();
+            foreach (var item in usage)
+                sb.AppendLine(Settings.Config.Main.Advanced.InternalCmdChar.ToChar() + item.Value);
+            handler.Log.Info(string.Format(Translations.icmd_list, sb.ToString(), Settings.Config.Main.Advanced.InternalCmdChar.ToChar()));
+            return r.SetAndReturn(CmdResult.Status.Done);
+        }
+    }
+}

MinecraftClient/Commands/Inventory.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.Linq;
 using System.Text;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 using MinecraftClient.Inventory;
 
 namespace MinecraftClient.Commands
@@ -13,78 +15,186 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return GetBasicUsage(); } }
         public override string CmdDesc { get { return Translations.cmd_inventory_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (handler.GetInventoryEnabled())
-            {
-                string[] args = GetArgs(command);
-                if (args.Length >= 1)
-                {
-                    int inventoryId;
-                    if (args[0].ToLower() == "creativegive")
-                    {
-                        if (args.Length >= 4)
-                        {
-                            if (!int.TryParse(args[1], NumberStyles.Any, CultureInfo.CurrentCulture, out int slot))
-                                return GetCmdDescTranslated();
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Then(l => l.Literal("list")
+                        .Executes(r => GetUsage(r.Source, "list")))
+                    .Then(l => l.Literal("close")
+                        .Executes(r => GetUsage(r.Source, "close")))
+                    .Then(l => l.Literal("click")
+                        .Executes(r => GetUsage(r.Source, "click")))
+                    .Then(l => l.Literal("drop")
+                        .Executes(r => GetUsage(r.Source, "drop")))
+                    .Then(l => l.Literal("creativegive")
+                        .Executes(r => GetUsage(r.Source, "creativegive")))
+                    .Then(l => l.Literal("creativedelete")
+                        .Executes(r => GetUsage(r.Source, "creativedelete")))
+                    .Then(l => l.Literal("inventories")
+                        .Executes(r => GetUsage(r.Source, "inventories")))
+                    .Then(l => l.Literal("search")
+                        .Executes(r => GetUsage(r.Source, "search")))
+                    .Then(l => l.Literal("help")
+                        .Executes(r => GetUsage(r.Source, "help")))
+                )
+            );
 
-                            if (Enum.TryParse(args[2], true, out ItemType itemType))
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => ListAllInventories(r.Source))
+                .Then(l => l.Literal("creativegive")
+                    .Then(l => l.Argument("Slot", MccArguments.InventorySlot())
+                        .Then(l => l.Argument("ItemType", MccArguments.ItemType())
+                            .Then(l => l.Argument("Count", Arguments.Integer(min: 1))
+                                .Executes(r => DoCreativeGive(r.Source, Arguments.GetInteger(r, "Slot"), MccArguments.GetItemType(r, "ItemType"), Arguments.GetInteger(r, "Count")))))))
+                .Then(l => l.Literal("creativedelete")
+                    .Then(l => l.Argument("Slot", MccArguments.InventorySlot())
+                        .Executes(r => DoCreativeDelete(r.Source, Arguments.GetInteger(r, "Slot")))))
+                .Then(l => l.Literal("inventories")
+                    .Executes(r => ListAvailableInventories(r.Source)))
+                .Then(l => l.Literal("search")
+                    .Then(l => l.Argument("ItemType", MccArguments.ItemType())
+                        .Executes(r => SearchItem(r.Source, MccArguments.GetItemType(r, "ItemType"), null))
+                        .Then(l => l.Argument("Count", Arguments.Integer(0, 64))
+                            .Executes(r => SearchItem(r.Source, MccArguments.GetItemType(r, "ItemType"), Arguments.GetInteger(r, "Count"))))))
+                .Then(l => l.Argument("InventoryId", MccArguments.InventoryId())
+                    .Then(l => l.Literal("close")
+                        .Executes(r => DoCloseAction(r.Source, Arguments.GetInteger(r, "InventoryId"))))
+                    .Then(l => l.Literal("list")
+                        .Executes(r => DoListAction(r.Source, Arguments.GetInteger(r, "InventoryId"))))
+                    .Then(l => l.Literal("click")
+                        .Then(l => l.Argument("Slot", MccArguments.InventorySlot())
+                            .Executes(r => DoClickAction(r.Source, Arguments.GetInteger(r, "InventoryId"), Arguments.GetInteger(r, "Slot"), WindowActionType.LeftClick))
+                            .Then(l => l.Argument("Action", MccArguments.InventoryAction())
+                                .Executes(r => DoClickAction(r.Source, Arguments.GetInteger(r, "InventoryId"), Arguments.GetInteger(r, "Slot"), MccArguments.GetInventoryAction(r, "Action"))))))
+                    .Then(l => l.Literal("drop")
+                        .Then(l => l.Argument("Slot", MccArguments.InventorySlot())
+                            .Executes(r => DoDropAction(r.Source, Arguments.GetInteger(r, "InventoryId"), Arguments.GetInteger(r, "Slot"), WindowActionType.DropItem))
+                            .Then(l => l.Literal("all")
+                                .Executes(r => DoDropAction(r.Source, Arguments.GetInteger(r, "InventoryId"), Arguments.GetInteger(r, "Slot"), WindowActionType.DropItemStack))))))
+                .Then(l => l.Literal("player")
+                    .Then(l => l.Literal("list")
+                        .Executes(r => DoListAction(r.Source, inventoryId: 0)))
+                    .Then(l => l.Literal("click")
+                        .Then(l => l.Argument("Slot", MccArguments.InventorySlot())
+                            .Executes(r => DoClickAction(r.Source, inventoryId: 0, Arguments.GetInteger(r, "Slot"), WindowActionType.LeftClick))
+                            .Then(l => l.Argument("Action", MccArguments.InventoryAction())
+                                .Executes(r => DoClickAction(r.Source, inventoryId: 0, Arguments.GetInteger(r, "Slot"), MccArguments.GetInventoryAction(r, "Action"))))))
+                    .Then(l => l.Literal("drop")
+                        .Then(l => l.Argument("Slot", MccArguments.InventorySlot())
+                            .Executes(r => DoDropAction(r.Source, inventoryId: 0, Arguments.GetInteger(r, "Slot"), WindowActionType.DropItem))
+                            .Then(l => l.Literal("all")
+                                .Executes(r => DoDropAction(r.Source, inventoryId: 0, Arguments.GetInteger(r, "Slot"), WindowActionType.DropItemStack))))))
+                .Then(l => l.Literal("container")
+                    .Then(l => l.Literal("close")
+                        .Executes(r => DoCloseAction(r.Source, inventoryId: null)))
+                    .Then(l => l.Literal("list")
+                        .Executes(r => DoListAction(r.Source, inventoryId: null)))
+                    .Then(l => l.Literal("click")
+                        .Then(l => l.Argument("Slot", MccArguments.InventorySlot())
+                            .Executes(r => DoClickAction(r.Source, inventoryId: null, Arguments.GetInteger(r, "Slot"), WindowActionType.LeftClick))
+                            .Then(l => l.Argument("Action", MccArguments.InventoryAction())
+                                .Executes(r => DoClickAction(r.Source, inventoryId: null, Arguments.GetInteger(r, "Slot"), MccArguments.GetInventoryAction(r, "Action"))))))
+                    .Then(l => l.Literal("drop")
+                        .Then(l => l.Argument("Slot", MccArguments.InventorySlot())
+                            .Executes(r => DoDropAction(r.Source, inventoryId: null, Arguments.GetInteger(r, "Slot"), WindowActionType.DropItem))
+                            .Then(l => l.Literal("all")
+                                .Executes(r => DoDropAction(r.Source, inventoryId: null, Arguments.GetInteger(r, "Slot"), WindowActionType.DropItemStack))))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
         {
+            string usageStr = ' ' + Translations.cmd_inventory_help_usage + ": ";
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                "list"           => Translations.cmd_inventory_help_list           + usageStr + "/inventory <player|container|<id>> list",
+                "close"          => Translations.cmd_inventory_help_close          + usageStr + "/inventory <player|container|<id>> close",
+                "click"          => Translations.cmd_inventory_help_click          + usageStr + "/inventory <player|container|<id>> click <slot> [left|right|middle|shift]\nDefault is left click",
+                "drop"           => Translations.cmd_inventory_help_drop           + usageStr + "/inventory <player|container|<id>> drop <slot> [all]\nAll means drop full stack",
+                "creativegive"   => Translations.cmd_inventory_help_creativegive   + usageStr + "/inventory creativegive <slot> <itemtype> <amount>",
+                "creativedelete" => Translations.cmd_inventory_help_creativedelete + usageStr + "/inventory creativedelete <slot>",
+                "inventories"    => Translations.cmd_inventory_help_inventories    + usageStr + "/inventory inventories",
+                "search"         => Translations.cmd_inventory_help_search         + usageStr + "/inventory search <item type> [count]",
+                "help"           => GetCmdDescTranslated(),
+                "action"         => Translations.cmd_inventory_help_unknown        + GetAvailableActions(),
+                _                => GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int GetMaximumInventoryId(McClient handler)
+        {
+            List<int> availableIds = handler.GetInventories().Keys.ToList();
+            return availableIds.Max(); // use foreground container
+        }
+
+        private int ListAllInventories(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetInventoryEnabled())
+            {
+                handler.Log.Info(Translations.extra_inventory_required);
+                return -1;
+            }
+            StringBuilder response = new();
+            response.Append(Translations.cmd_inventory_inventories).Append(":\n");
+            foreach ((int invId, Container inv) in handler.GetInventories())
+                response.AppendLine(String.Format(" #{0}: {1}§8", invId, inv.Title));
+            response.Append(CmdUsage);
+            handler.Log.Info(response.ToString());
+            return r.SetAndReturn(CmdResult.Status.Done);
+        }
+
+        private int DoCreativeGive(CmdResult r, int slot, ItemType itemType, int count)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetInventoryEnabled())
+                return r.SetAndReturn(CmdResult.Status.FailNeedInventory);
+
             if (handler.GetGamemode() == 1)
             {
-                                    if (!int.TryParse(args[3], NumberStyles.Any, CultureInfo.CurrentCulture, out int count))
-                                        return GetCmdDescTranslated();
-
                 if (handler.DoCreativeGive(slot, itemType, count, null))
-                                        return string.Format(Translations.cmd_inventory_creative_done, itemType, count, slot);
+                    return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.cmd_inventory_creative_done, itemType, count, slot));
                 else
-                                        return Translations.cmd_inventory_creative_fail;
+                    return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_inventory_creative_fail);
             }
             else
-                                    return Translations.cmd_inventory_need_creative;
-                            }
-                            else
-                                return GetCmdDescTranslated();
-                        }
-                        else
-                            return GetCmdDescTranslated();
-                    }
-                    else if (args[0].ToLower() == "creativedelete")
             {
-                        if (args.Length >= 2)
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_inventory_need_creative);
+            }
+        }
+
+        private int DoCreativeDelete(CmdResult r, int slot)
         {
-                            if (!int.TryParse(args[1], NumberStyles.Any, CultureInfo.CurrentCulture, out int slot))
-                                return GetCmdDescTranslated();
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetInventoryEnabled())
+                return r.SetAndReturn(CmdResult.Status.FailNeedInventory);
 
             if (handler.GetGamemode() == 1)
             {
                 if (handler.DoCreativeGive(slot, ItemType.Null, 0, null))
-                                    return string.Format(Translations.cmd_inventory_creative_delete, slot);
+                    return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.cmd_inventory_creative_delete, slot));
                 else
-                                    return Translations.cmd_inventory_creative_fail;
+                    return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_inventory_creative_fail);
             }
             else
-                                return Translations.cmd_inventory_need_creative;
-                        }
-                        else
-                            return GetCmdDescTranslated();
-                    }
-                    else if (args[0].ToLower().StartsWith("p"))
             {
-                        // player inventory is always ID 0
-                        inventoryId = 0;
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_inventory_need_creative);
             }
-                    else if (args[0].ToLower().StartsWith("c"))
-                    {
-                        List<int> availableIds = handler.GetInventories().Keys.ToList();
-                        availableIds.Remove(0); // remove player inventory ID from list
-                        if (availableIds.Count > 0)
-                            inventoryId = availableIds.Max(); // use foreground container
-                        else
-                            return Translations.cmd_inventory_container_not_found;
         }
-                    else if (args[0].ToLower().StartsWith("inventories") || args[0].ToLower().StartsWith("i"))
+
+        private int ListAvailableInventories(CmdResult r)
         {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetInventoryEnabled())
+                return r.SetAndReturn(CmdResult.Status.FailNeedInventory);
+
             Dictionary<int, Container> inventories = handler.GetInventories();
             List<int> availableIds = inventories.Keys.ToList();
             StringBuilder response = new();
@@ -93,21 +203,15 @@ namespace MinecraftClient.Commands
             foreach (int id in availableIds)
                 response.AppendLine(String.Format(" #{0} - {1}§8", id, inventories[id].Title));
 
-                        return response.ToString();
+            handler.Log.Info(response.ToString());
+            return r.SetAndReturn(CmdResult.Status.Done);
         }
-                    else if (args[0].ToLower().StartsWith("search") || args[0].ToLower().StartsWith("s"))
+
+        private int SearchItem(CmdResult r, ItemType itemType, int? itemCount)
         {
-                        if (args.Length < 2)
-                            return GetCmdDescTranslated();
-
-                        if (!Enum.TryParse(args[1], true, out ItemType parsedItemType))
-                            return GetCmdDescTranslated();
-
-                        bool shouldUseItemCount = args.Length >= 3;
-                        int itemCount = 0;
-
-                        if (shouldUseItemCount && !int.TryParse(args[2], NumberStyles.Any, CultureInfo.CurrentCulture, out itemCount))
-                            return GetCmdDescTranslated();
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetInventoryEnabled())
+                return r.SetAndReturn(CmdResult.Status.FailNeedInventory);
 
             Dictionary<int, Container> inventories = handler.GetInventories();
             Dictionary<int, List<Item>> foundItems = new();
@@ -118,7 +222,7 @@ namespace MinecraftClient.Commands
             {
                 inventory.Items.Values
                     .ToList()
-                                .FindAll(item => item.Type == parsedItemType && (!shouldUseItemCount || item.Count == itemCount))
+                    .FindAll(item => item.Type == itemType && (!itemCount.HasValue || item.Count == itemCount))
                     .ForEach(item =>
                     {
                         if (!foundItems.ContainsKey(inventory.ID))
@@ -135,7 +239,7 @@ namespace MinecraftClient.Commands
             });
 
             if (foundItems.Count == 0)
-                            return Translations.cmd_inventory_no_found_items;
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_inventory_no_found_items);
 
             StringBuilder response = new();
 
@@ -154,32 +258,50 @@ namespace MinecraftClient.Commands
                 }
             }
 
-                        return response.ToString();
+            handler.Log.Info(response.ToString());
+            return r.SetAndReturn(CmdResult.Status.Done);
         }
-                    else if (args[0].ToLower() == "help")
-                    {
-                        if (args.Length >= 2)
-                            return GetSubCommandHelp(args[1]);
-                        else
-                            return GetHelp();
-                    }
-                    else if (!int.TryParse(args[0], NumberStyles.Any, CultureInfo.CurrentCulture, out inventoryId))
-                        return GetCmdDescTranslated();
 
-                    Container? inventory = handler.GetInventory(inventoryId);
+        private int DoCloseAction(CmdResult r, int? inventoryId)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetInventoryEnabled())
+                return r.SetAndReturn(CmdResult.Status.FailNeedInventory);
+
+            if (!inventoryId.HasValue)
+            {
+                inventoryId = GetMaximumInventoryId(handler);
+                if (inventoryId == 0)
+                    return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_inventory_container_not_found);
+            }
+
+            Container? inventory = handler.GetInventory(inventoryId.Value);
             if (inventory == null)
-                        return string.Format(Translations.cmd_inventory_not_exist, inventoryId);
+                return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.cmd_inventory_not_exist, inventoryId));
 
-                    string action = args.Length > 1 ? args[1].ToLower() : "list";
-                    if (action == "close")
-                    {
-                        if (handler.CloseInventory(inventoryId))
-                            return string.Format(Translations.cmd_inventory_close, inventoryId);
+            if (handler.CloseInventory(inventoryId.Value))
+                return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.cmd_inventory_close, inventoryId));
             else
-                            return string.Format(Translations.cmd_inventory_close_fail, inventoryId);
+                return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.cmd_inventory_close_fail, inventoryId));
         }
-                    else if (action == "list")
+
+        private int DoListAction(CmdResult r, int? inventoryId)
         {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetInventoryEnabled())
+                return r.SetAndReturn(CmdResult.Status.FailNeedInventory);
+
+            if (!inventoryId.HasValue)
+            {
+                inventoryId = GetMaximumInventoryId(handler);
+                if (inventoryId == 0)
+                    return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_inventory_container_not_found);
+            }
+
+            Container? inventory = handler.GetInventory(inventoryId.Value);
+            if (inventory == null)
+                return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.cmd_inventory_not_exist, inventoryId));
+
             StringBuilder response = new();
             response.Append(Translations.cmd_inventory_inventory);
             response.AppendLine(String.Format(" #{0} - {1}§8", inventoryId, inventory.Title));
@@ -202,76 +324,74 @@ namespace MinecraftClient.Commands
                 response.AppendLine(string.Format(Translations.cmd_inventory_hotbar, (handler.GetCurrentSlot() + 1)));
 
             response.Remove(response.Length - 1, 1); // Remove last '\n'
-                        return response.ToString();
-                    }
-                    else if (action == "click" && args.Length >= 3)
-                    {
-                        if (!int.TryParse(args[2], NumberStyles.Any, CultureInfo.CurrentCulture, out int slot))
-                            return GetCmdDescTranslated();
-
-                        WindowActionType actionType = WindowActionType.LeftClick;
-                        string keyName = Translations.cmd_inventory_left;
-                        if (args.Length >= 4)
-                        {
-                            string b = args[3];
-                            if (b.ToLower()[0] == 'r')
-                                (actionType, keyName) = (WindowActionType.RightClick, Translations.cmd_inventory_right);
-                            else if (b.ToLower()[0] == 'm')
-                                (actionType, keyName) = (WindowActionType.MiddleClick, Translations.cmd_inventory_middle);
+            handler.Log.Info(response.ToString());
+            return r.SetAndReturn(CmdResult.Status.Done);
         }
 
-                        handler.DoWindowAction(inventoryId, slot, actionType);
-                        return string.Format(Translations.cmd_inventory_clicking, keyName, slot, inventoryId);
-                    }
-                    else if (action == "shiftclick" && args.Length >= 3)
+        private int DoClickAction(CmdResult r, int? inventoryId, int slot, WindowActionType actionType)
         {
-                        if (!int.TryParse(args[2], NumberStyles.Any, CultureInfo.CurrentCulture, out int slot))
-                            return GetCmdDescTranslated();
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetInventoryEnabled())
+                return r.SetAndReturn(CmdResult.Status.FailNeedInventory);
 
-                        if (!handler.DoWindowAction(inventoryId, slot, WindowActionType.ShiftClick))
-                            return Translations.cmd_inventory_shiftclick_fail;
-
-                        return string.Format(Translations.cmd_inventory_shiftclick, slot, inventoryId);
-                    }
-                    else if (action == "drop" && args.Length >= 3)
+            if (!inventoryId.HasValue)
             {
-                        if (!int.TryParse(args[2], NumberStyles.Any, CultureInfo.CurrentCulture, out int slot))
-                            return GetCmdDescTranslated();
+                inventoryId = GetMaximumInventoryId(handler);
+                if (inventoryId == 0)
+                    return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_inventory_container_not_found);
+            }
+
+            Container? inventory = handler.GetInventory(inventoryId.Value);
+            if (inventory == null)
+                return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.cmd_inventory_not_exist, inventoryId));
+
+            string keyName = actionType switch
+            {
+                WindowActionType.LeftClick => Translations.cmd_inventory_left,
+                WindowActionType.RightClick => Translations.cmd_inventory_right,
+                WindowActionType.MiddleClick => Translations.cmd_inventory_middle,
+                WindowActionType.ShiftClick => Translations.cmd_inventory_shiftclick,
+                _ => "unknown",
+            };
+
+            handler.Log.Info(string.Format(Translations.cmd_inventory_clicking, keyName, slot, inventoryId));
+            return r.SetAndReturn(handler.DoWindowAction(inventoryId.Value, slot, actionType));
+        }
+
+        private int DoDropAction(CmdResult r, int? inventoryId, int slot, WindowActionType actionType)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetInventoryEnabled())
+                return r.SetAndReturn(CmdResult.Status.FailNeedInventory);
+
+            if (!inventoryId.HasValue)
+            {
+                inventoryId = GetMaximumInventoryId(handler);
+                if (inventoryId == 0)
+                    return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_inventory_container_not_found);
+            }
+
+            Container? inventory = handler.GetInventory(inventoryId.Value);
+            if (inventory == null)
+                return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.cmd_inventory_not_exist, inventoryId));
 
             // check item exist
             if (!inventory.Items.ContainsKey(slot))
-                            return string.Format(Translations.cmd_inventory_no_item, slot);
+                return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.cmd_inventory_no_item, slot));
 
-                        WindowActionType actionType = WindowActionType.DropItem;
-                        if (args.Length >= 4 && args[3].ToLower() == "all")
-                            actionType = WindowActionType.DropItemStack;
-
-                        if (handler.DoWindowAction(inventoryId, slot, actionType))
+            if (handler.DoWindowAction(inventoryId.Value, slot, actionType))
             {
                 if (actionType == WindowActionType.DropItemStack)
-                                return string.Format(Translations.cmd_inventory_drop_stack, slot);
+                    return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.cmd_inventory_drop_stack, slot));
                 else
-                                return string.Format(Translations.cmd_inventory_drop, slot);
-                        }
-                        else
-                            return "Failed";
-                    }
-                    else
-                        return GetCmdDescTranslated();
+                    return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.cmd_inventory_drop, slot));
             }
             else
             {
-                    StringBuilder response = new();
-                    response.Append(Translations.cmd_inventory_inventories).Append(":\n");
-                    foreach ((int invId, Container inv) in handler.GetInventories())
-                        response.AppendLine(String.Format(" #{0}: {1}§8", invId, inv.Title));
-                    response.Append(CmdUsage);
-                    return response.ToString();
+                return r.SetAndReturn(CmdResult.Status.Fail, "Drop Failed");
             }
         }
-            else
-                return Translations.extra_inventory_required;
-        }
+
 
         #region Methods for commands help
 
@@ -285,31 +405,6 @@ namespace MinecraftClient.Commands
             return Translations.cmd_inventory_help_basic + ": /inventory <player|container|<id>> <action>.";
         }
 
-        private static string GetHelp()
-        {
-            return string.Format(Translations.cmd_inventory_help_help, GetAvailableActions());
-        }
-
-        private static string GetSubCommandHelp(string cmd)
-        {
-            string usageStr = ' ' + Translations.cmd_inventory_help_usage + ": ";
-            return cmd switch
-            {
-#pragma warning disable format // @formatter:off
-                "list"           => Translations.cmd_inventory_help_list           + usageStr + "/inventory <player|container|<id>> list",
-                "close"          => Translations.cmd_inventory_help_close          + usageStr + "/inventory <player|container|<id>> close",
-                "click"          => Translations.cmd_inventory_help_click          + usageStr + "/inventory <player|container|<id>> click <slot> [left|right|middle]\nDefault is left click",
-                "shiftclick"     => Translations.cmd_inventory_help_shiftclick     + usageStr + "/inventory <player|container|<id>> shiftclick <slot>",
-                "drop"           => Translations.cmd_inventory_help_drop           + usageStr + "/inventory <player|container|<id>> drop <slot> [all]\nAll means drop full stack",
-                "creativegive"   => Translations.cmd_inventory_help_creativegive   + usageStr + "/inventory creativegive <slot> <itemtype> <amount>",
-                "creativedelete" => Translations.cmd_inventory_help_creativedelete + usageStr + "/inventory creativedelete <slot>",
-                "inventories"    => Translations.cmd_inventory_help_inventories    + usageStr + "/inventory inventories",
-                "search"         => Translations.cmd_inventory_help_search         + usageStr + "/inventory search <item type> [count]",
-                "help"           => GetHelp(),
-                _                => Translations.cmd_inventory_help_unknown        + GetAvailableActions(),
-#pragma warning restore format // @formatter:on
-            };
-        }
         #endregion
     }
 }

MinecraftClient/Commands/List.cs

@@ -1,5 +1,7 @@
 using System;
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -9,9 +11,36 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "list"; } }
         public override string CmdDesc { get { return Translations.cmd_list_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            return string.Format(Translations.cmd_list_players, String.Join(", ", handler.GetOnlinePlayers()));
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => DoListPlayers(r.Source))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoListPlayers(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            return r.SetAndReturn(CmdResult.Status.Done, string.Format(Translations.cmd_list_players, String.Join(", ", handler.GetOnlinePlayers())));
         }
     }
 }

MinecraftClient/Commands/Log.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -8,14 +10,35 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "log <text>"; } }
         public override string CmdDesc { get { return Translations.cmd_log_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
-            {
-                ConsoleIO.WriteLogLine(GetArg(command));
-                return "";
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Argument("String", Arguments.GreedyString())
+                    .Executes(r => DoLog(r.Source, Arguments.GetString(r, "String"))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty)))
+            );
         }
-            else return GetCmdDescTranslated();
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoLog(CmdResult r, string command)
+        {
+            return r.SetAndReturn(CmdResult.Status.Done, command);
         }
     }
 }

MinecraftClient/Commands/Look.cs

@@ -1,7 +1,9 @@
 using System;
-using System.Collections.Generic;
-using System.Globalization;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 using MinecraftClient.Mapping;
+using static MinecraftClient.CommandHandler.CmdResult;
 
 namespace MinecraftClient.Commands
 {
@@ -11,70 +13,107 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "look <x y z|yaw pitch|up|down|east|west|north|south>"; } }
         public override string CmdDesc { get { return Translations.cmd_look_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (handler.GetTerrainEnabled())
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Then(l => l.Literal("direction")
+                        .Executes(r => GetUsage(r.Source, "direction")))
+                    .Then(l => l.Literal("angle")
+                        .Executes(r => GetUsage(r.Source, "angle")))
+                    .Then(l => l.Literal("location")
+                        .Executes(r => GetUsage(r.Source, "location")))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => LogCurrentLooking(r.Source))
+                .Then(l => l.Literal("up")
+                    .Executes(r => LookAtDirection(r.Source, Direction.Up)))
+                .Then(l => l.Literal("down")
+                    .Executes(r => LookAtDirection(r.Source, Direction.Down)))
+                .Then(l => l.Literal("east")
+                    .Executes(r => LookAtDirection(r.Source, Direction.East)))
+                .Then(l => l.Literal("west")
+                    .Executes(r => LookAtDirection(r.Source, Direction.West)))
+                .Then(l => l.Literal("north")
+                    .Executes(r => LookAtDirection(r.Source, Direction.North)))
+                .Then(l => l.Literal("south")
+                    .Executes(r => LookAtDirection(r.Source, Direction.South)))
+                .Then(l => l.Argument("Yaw", Arguments.Float())
+                    .Then(l => l.Argument("Pitch", Arguments.Float())
+                        .Executes(r => LookAtAngle(r.Source, Arguments.GetFloat(r, "Yaw"), Arguments.GetFloat(r, "Pitch")))))
+                .Then(l => l.Argument("Location", MccArguments.Location())
+                    .Executes(r => LookAtLocation(r.Source, MccArguments.GetLocation(r, "Location"))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
         {
-                string[] args = GetArgs(command);
-                if (args.Length == 0)
+            return r.SetAndReturn(cmd switch
             {
+#pragma warning disable format // @formatter:off
+                "direction"  =>  GetCmdDescTranslated(),
+                "angle"      =>  GetCmdDescTranslated(),
+                "location"   =>  GetCmdDescTranslated(),
+                _            =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int LogCurrentLooking(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
             const double maxDistance = 8.0;
             (bool hasBlock, Location target, Block block) = RaycastHelper.RaycastBlock(handler, maxDistance, false);
             if (!hasBlock)
-                        return string.Format(Translations.cmd_look_noinspection, maxDistance);
+            {
+                return r.SetAndReturn(Status.Fail, string.Format(Translations.cmd_look_noinspection, maxDistance));
+            }
             else
             {
                 Location current = handler.GetCurrentLocation(), target_center = target.ToCenter();
-                        return string.Format(Translations.cmd_look_inspection, block.Type, target.X, target.Y, target.Z,
-                            current.Distance(target_center), current.EyesLocation().Distance(target_center));
+                return r.SetAndReturn(Status.Done, string.Format(Translations.cmd_look_inspection, block.Type, target.X, target.Y, target.Z,
+                    current.Distance(target_center), current.EyesLocation().Distance(target_center)));
             }
         }
-                else if (args.Length == 1)
+
+        private int LookAtDirection(CmdResult r, Direction direction)
         {
-                    string dirStr = GetArg(command).Trim().ToLower();
-                    Direction direction;
-                    switch (dirStr)
-                    {
-                        case "up": direction = Direction.Up; break;
-                        case "down": direction = Direction.Down; break;
-                        case "east": direction = Direction.East; break;
-                        case "west": direction = Direction.West; break;
-                        case "north": direction = Direction.North; break;
-                        case "south": direction = Direction.South; break;
-                        default: return string.Format(Translations.cmd_look_unknown, dirStr);
-                    }
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
 
             handler.UpdateLocation(handler.GetCurrentLocation(), direction);
-                    return "Looking " + dirStr;
+            return r.SetAndReturn(Status.Done, "Looking " + direction.ToString());
         }
-                else if (args.Length == 2)
+
+        private int LookAtAngle(CmdResult r, float yaw, float pitch)
         {
-                    try
-                    {
-                        float yaw = float.Parse(args[0], NumberStyles.Any, CultureInfo.CurrentCulture);
-                        float pitch = float.Parse(args[1], NumberStyles.Any, CultureInfo.CurrentCulture);
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
 
             handler.UpdateLocation(handler.GetCurrentLocation(), yaw, pitch);
-                        return string.Format(Translations.cmd_look_at, yaw.ToString("0.00"), pitch.ToString("0.00"));
+            return r.SetAndReturn(Status.Done, string.Format(Translations.cmd_look_at, yaw.ToString("0.00"), pitch.ToString("0.00")));
         }
-                    catch (FormatException) { return GetCmdDescTranslated(); }
-                }
-                else if (args.Length == 3)
-                {
-                    try
+
+        private int LookAtLocation(CmdResult r, Location location)
         {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
             Location current = handler.GetCurrentLocation();
-                        Location block = Location.Parse(current, args[0], args[1], args[2]);
-                        handler.UpdateLocation(current, block);
-
-                        return string.Format(Translations.cmd_look_block, block);
-                    }
-                    catch (FormatException) { return CmdUsage; }
-                    
-                }
-                else return GetCmdDescTranslated();
-            }
-            else return Translations.extra_terrainandmovement_required;
+            handler.UpdateLocation(current, location);
+            return r.SetAndReturn(Status.Done, string.Format(Translations.cmd_look_block, location));
         }
     }
 }

MinecraftClient/Commands/Move.cs

@@ -1,7 +1,9 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 using MinecraftClient.Mapping;
+using static MinecraftClient.CommandHandler.CmdResult;
 
 namespace MinecraftClient.Commands
 {
@@ -11,107 +13,190 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "move <on|off|get|up|down|east|west|north|south|center|x y z|gravity [on|off]> [-f]"; } }
         public override string CmdDesc { get { return Translations.cmd_move_desc + " \"-f\": " + Translations.cmd_move_desc_force; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            List<string> args = GetArgs(command.ToLower()).ToList();
-            bool takeRisk = false;
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Then(l => l.Literal("enable")
+                        .Executes(r => GetUsage(r.Source, "enable")))
+                    .Then(l => l.Literal("gravity")
+                        .Executes(r => GetUsage(r.Source, "gravity")))
+                    .Then(l => l.Literal("direction")
+                        .Executes(r => GetUsage(r.Source, "direction")))
+                    .Then(l => l.Literal("center")
+                        .Executes(r => GetUsage(r.Source, "center")))
+                    .Then(l => l.Literal("get")
+                        .Executes(r => GetUsage(r.Source, "get")))
+                    .Then(l => l.Literal("location")
+                        .Executes(r => GetUsage(r.Source, "location")))
+                    .Then(l => l.Literal("-f")
+                        .Executes(r => GetUsage(r.Source, "-f")))
+                )
+            );
 
-            if (args.Count < 1)
-            {
-                string desc = GetCmdDescTranslated();
-
-                if (handler.GetTerrainEnabled())
-                    handler.Log.Info(World.GetChunkLoadingStatus(handler.GetWorld()));
-
-                return desc;
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Literal("on")
+                    .Executes(r => SetMovementEnable(r.Source, enable: true)))
+                .Then(l => l.Literal("off")
+                    .Executes(r => SetMovementEnable(r.Source, enable: false)))
+                .Then(l => l.Literal("gravity")
+                    .Executes(r => SetGravityEnable(r.Source, enable: null))
+                    .Then(l => l.Literal("on")
+                        .Executes(r => SetGravityEnable(r.Source, enable: true)))
+                    .Then(l => l.Literal("off")
+                        .Executes(r => SetGravityEnable(r.Source, enable: false))))
+                .Then(l => l.Literal("up")
+                    .Executes(r => MoveOnDirection(r.Source, Direction.Up, false))
+                    .Then(l => l.Literal("-f")
+                        .Executes(r => MoveOnDirection(r.Source, Direction.Up, true))))
+                .Then(l => l.Literal("down")
+                    .Executes(r => MoveOnDirection(r.Source, Direction.Down, false))
+                    .Then(l => l.Literal("-f")
+                        .Executes(r => MoveOnDirection(r.Source, Direction.Down, true))))
+                .Then(l => l.Literal("east")
+                    .Executes(r => MoveOnDirection(r.Source, Direction.East, false))
+                    .Then(l => l.Literal("-f")
+                        .Executes(r => MoveOnDirection(r.Source, Direction.East, true))))
+                .Then(l => l.Literal("west")
+                    .Executes(r => MoveOnDirection(r.Source, Direction.West, false))
+                    .Then(l => l.Literal("-f")
+                        .Executes(r => MoveOnDirection(r.Source, Direction.West, true))))
+                .Then(l => l.Literal("north")
+                    .Executes(r => MoveOnDirection(r.Source, Direction.North, false))
+                    .Then(l => l.Literal("-f")
+                        .Executes(r => MoveOnDirection(r.Source, Direction.North, true))))
+                .Then(l => l.Literal("south")
+                    .Executes(r => MoveOnDirection(r.Source, Direction.South, false))
+                    .Then(l => l.Literal("-f")
+                        .Executes(r => MoveOnDirection(r.Source, Direction.South, true))))
+                .Then(l => l.Literal("center")
+                    .Executes(r => MoveToCenter(r.Source)))
+                .Then(l => l.Literal("get")
+                    .Executes(r => GetCurrentLocation(r.Source)))
+                .Then(l => l.Argument("location", MccArguments.Location())
+                    .Executes(r => MoveToLocation(r.Source, MccArguments.GetLocation(r, "location"), false))
+                    .Then(l => l.Literal("-f")
+                        .Executes(r => MoveToLocation(r.Source, MccArguments.GetLocation(r, "location"), true))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
         }
 
-            if (args.Contains("-f"))
+        private int GetUsage(CmdResult r, string? cmd)
         {
-                takeRisk = true;
-                args.Remove("-f");
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                "enable"    =>  GetCmdDescTranslated(),
+                "gravity"   =>  GetCmdDescTranslated(),
+                "direction" =>  GetCmdDescTranslated(),
+                "center"    =>  GetCmdDescTranslated(),
+                "get"       =>  GetCmdDescTranslated(),
+                "location"  =>  GetCmdDescTranslated(),
+                "-f"        =>  GetCmdDescTranslated(),
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
         }
 
-            if (args[0] == "on")
+        private int SetMovementEnable(CmdResult r, bool enable)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (enable)
             {
                 handler.SetTerrainEnabled(true);
-                return Translations.cmd_move_enable;
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_move_enable);
             }
-            else if (args[0] == "off")
+            else
             {
                 handler.SetTerrainEnabled(false);
-                return Translations.cmd_move_disable;
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_move_disable);
             }
-            else if (args[0] == "gravity")
+        }
+
+        private int SetGravityEnable(CmdResult r, bool? enable)
         {
-                if (args.Count >= 2)
-                    Settings.InternalConfig.GravityEnabled = (args[1] == "on");
+            McClient handler = CmdResult.currentHandler!;
+            if (enable.HasValue)
+                Settings.InternalConfig.GravityEnabled = enable.Value;
+
             if (Settings.InternalConfig.GravityEnabled)
-                    return Translations.cmd_move_gravity_enabled;
-                else return Translations.cmd_move_gravity_disabled;
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_move_gravity_enabled);
+            else
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_move_gravity_disabled);
         }
-            else if (handler.GetTerrainEnabled())
+
+        private int GetCurrentLocation(CmdResult r)
         {
-                if (args.Count == 1)
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
+            return r.SetAndReturn(Status.Done, handler.GetCurrentLocation().ToString());
+        }
+
+        private int MoveToCenter(CmdResult r)
         {
-                    Direction direction;
-                    switch (args[0])
-                    {
-                        case "up": direction = Direction.Up; break;
-                        case "down": direction = Direction.Down; break;
-                        case "east": direction = Direction.East; break;
-                        case "west": direction = Direction.West; break;
-                        case "north": direction = Direction.North; break;
-                        case "south": direction = Direction.South; break;
-                        case "center":
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
             Location current = handler.GetCurrentLocation();
             Location currentCenter = new(Math.Floor(current.X) + 0.5, current.Y, Math.Floor(current.Z) + 0.5);
             handler.MoveTo(currentCenter, allowDirectTeleport: true);
-                            return string.Format(Translations.cmd_move_walk, currentCenter, current);
-                        case "get": return handler.GetCurrentLocation().ToString();
-                        default: return string.Format(Translations.cmd_look_unknown, args[0]);
+            return r.SetAndReturn(Status.Done, string.Format(Translations.cmd_move_walk, currentCenter, current));
         }
 
+        private int MoveOnDirection(CmdResult r, Direction direction, bool takeRisk)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
             Location goal = Movement.Move(handler.GetCurrentLocation(), direction);
 
             if (!Movement.CheckChunkLoading(handler.GetWorld(), handler.GetCurrentLocation(), goal))
-                        return string.Format(Translations.cmd_move_chunk_not_loaded, goal.X, goal.Y, goal.Z);
+                return r.SetAndReturn(Status.FailChunkNotLoad, string.Format(Translations.cmd_move_chunk_not_loaded, goal.X, goal.Y, goal.Z));
 
             if (Movement.CanMove(handler.GetWorld(), handler.GetCurrentLocation(), direction))
             {
                 if (handler.MoveTo(goal, allowUnsafe: takeRisk))
-                            return string.Format(Translations.cmd_move_moving, args[0]);
+                    return r.SetAndReturn(Status.Done, string.Format(Translations.cmd_move_moving, direction.ToString()));
                 else
-                            return takeRisk ? Translations.cmd_move_dir_fail : Translations.cmd_move_suggestforce;
+                    return r.SetAndReturn(Status.Fail, takeRisk ? Translations.cmd_move_dir_fail : Translations.cmd_move_suggestforce);
             }
-                    else return Translations.cmd_move_dir_fail;
+            else
+            {
+                return r.SetAndReturn(Status.Fail, Translations.cmd_move_dir_fail);
             }
-                else if (args.Count == 3)
-                {
-                    try
+        }
+
+        private int MoveToLocation(CmdResult r, Location goal, bool takeRisk)
         {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetTerrainEnabled())
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
             Location current = handler.GetCurrentLocation(), currentCenter = current.ToCenter();
-                        Location goal = Location.Parse(current, args[0], args[1], args[2]);
+            goal.ToAbsolute(current);
 
             if (!Movement.CheckChunkLoading(handler.GetWorld(), current, goal))
-                            return string.Format(Translations.cmd_move_chunk_not_loaded, goal.X, goal.Y, goal.Z);
+                return r.SetAndReturn(Status.FailChunkNotLoad, string.Format(Translations.cmd_move_chunk_not_loaded, goal.X, goal.Y, goal.Z));
 
             if (takeRisk || Movement.PlayerFitsHere(handler.GetWorld(), goal))
             {
                 if (current.ToFloor() == goal.ToFloor())
                     handler.MoveTo(goal, allowDirectTeleport: true);
                 else if (!handler.MoveTo(goal, allowUnsafe: takeRisk))
-                                return takeRisk ? string.Format(Translations.cmd_move_fail, goal) : string.Format(Translations.cmd_move_suggestforce, goal);
-                            return string.Format(Translations.cmd_move_walk, goal, current);
+                    return r.SetAndReturn(Status.Fail, takeRisk ? string.Format(Translations.cmd_move_fail, goal) : string.Format(Translations.cmd_move_suggestforce, goal));
+                return r.SetAndReturn(Status.Done, string.Format(Translations.cmd_move_walk, goal, current));
             }
             else
-                            return string.Format(Translations.cmd_move_suggestforce, goal);
+            {
+                return r.SetAndReturn(Status.Fail, string.Format(Translations.cmd_move_suggestforce, goal));
             }
-                    catch (FormatException) { return GetCmdDescTranslated(); }
-                }
-                else return GetCmdDescTranslated();
-            }
-            else return Translations.extra_terrainandmovement_required;
         }
     }
 }

MinecraftClient/Commands/Reco.cs

@@ -1,4 +1,7 @@
-using System.Collections.Generic;
+using System;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -8,18 +11,59 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "reco [account]"; } }
         public override string CmdDesc { get { return Translations.cmd_reco_desc; } }
 
-        public override string Run(McClient? handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
+        {
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => DoReconnect(r.Source, string.Empty))
+                .Then(l => l.Argument("AccountNick", MccArguments.AccountNick())
+                    .Executes(r => DoReconnect(r.Source, Arguments.GetString(r, "AccountNick"))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoReconnect(CmdResult r, string account)
+        {
+            if (!string.IsNullOrWhiteSpace(account))
+            {
+                account = account.Trim();
+                if (!Settings.Config.Main.Advanced.SetAccount(account))
+                    return r.SetAndReturn(CmdResult.Status.Fail, string.Format(Translations.cmd_connect_unknown, account));
+            }
+            Program.Restart(keepAccountAndServerSettings: true);
+            return r.SetAndReturn(CmdResult.Status.Done);
+        }
+
+        internal static string DoReconnect(string command)
         {
             string[] args = GetArgs(command);
             if (args.Length > 0)
             {
-                if (!Settings.Config.Main.Advanced.SetAccount(args[0]))
+                string account = args[0].Trim();
+                if (!Settings.Config.Main.Advanced.SetAccount(account))
                 {
-                    return string.Format(Translations.cmd_connect_unknown, args[0]);
+                    return string.Format(Translations.cmd_connect_unknown, account);
                 }
             }
             Program.Restart(keepAccountAndServerSettings: true);
-            return "";
+            return String.Empty;
         }
     }
 }

MinecraftClient/Commands/Reload.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -8,8 +10,35 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "reload"; } }
         public override string CmdDesc { get { return Translations.cmd_reload_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => DoReload(r.Source))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoReload(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
             handler.Log.Info(Translations.cmd_reload_started);
             handler.ReloadSettings();
             handler.Log.Warn(Translations.cmd_reload_warning1);
@@ -17,7 +46,7 @@ namespace MinecraftClient.Commands
             handler.Log.Warn(Translations.cmd_reload_warning3);
             handler.Log.Warn(Translations.cmd_reload_warning4);
 
-            return Translations.cmd_reload_finished;
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_reload_finished);
         }
     }
 }

MinecraftClient/Commands/Respawn.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -8,10 +10,37 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "respawn"; } }
         public override string CmdDesc { get { return Translations.cmd_respawn_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => DoRespawn(r.Source))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoRespawn(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
             handler.SendRespawnPacket();
-            return Translations.cmd_respawn_done;
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_respawn_done);
         }
     }
 }

MinecraftClient/Commands/Script.cs

@@ -1,4 +1,7 @@
 using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -8,14 +11,38 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "script <scriptname>"; } }
         public override string CmdDesc { get { return Translations.cmd_script_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
-            {
-                handler.BotLoad(new ChatBots.Script(GetArg(command), null, localVars));
-                return "";
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Argument("Script", MccArguments.ScriptName())
+                    .Executes(r => DoExecuteScript(r.Source, Arguments.GetString(r, "Script"), null)))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
         }
-            else return GetCmdDescTranslated();
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoExecuteScript(CmdResult r, string command, Dictionary<string, object>? localVars)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            handler.BotLoad(new ChatBots.Script(command.Trim(), null, localVars));
+            return r.SetAndReturn(CmdResult.Status.Done);
         }
     }
 }

MinecraftClient/Commands/Send.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -8,14 +10,35 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "send <text>"; } }
         public override string CmdDesc { get { return Translations.cmd_send_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
-            {
-                handler.SendText(GetArg(command));
-                return "";
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Argument("any", Arguments.GreedyString())
+                    .Executes(r => DoSendText(r.Source, Arguments.GetString(r, "any"))))
+            );
         }
-            else return GetCmdDescTranslated();
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoSendText(CmdResult r, string command)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            handler.SendText(command);
+            return r.SetAndReturn(CmdResult.Status.Done);
         }
     }
 }

MinecraftClient/Commands/Set.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -8,23 +10,51 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "set varname=value"; } }
         public override string CmdDesc { get { return Translations.cmd_set_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Argument("Expression", Arguments.GreedyString())
+                    .Executes(r => DoSetVar(r.Source, Arguments.GetString(r, "Expression"))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
         {
-                string[] temp = GetArg(command).Split('=');
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoSetVar(CmdResult r, string command)
+        {
+            string[] temp = command.Trim().Split('=');
             if (temp.Length > 1)
             {
-                    if (Settings.Config.AppVar.SetVar(temp[0], GetArg(command).Substring(temp[0].Length + 1)))
-                        return ""; //Success
-                    else 
-                        return Translations.cmd_set_format;
+                if (Settings.Config.AppVar.SetVar(temp[0], command[(temp[0].Length + 1)..]))
+                {
+                    return r.SetAndReturn(CmdResult.Status.Done); //Success
                 }
                 else
-                    return GetCmdDescTranslated();
+                {
+                    return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_set_format);
+                }
             }
             else
-                return GetCmdDescTranslated();
+            {
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_set_format);
+            }
         }
     }
 }

MinecraftClient/Commands/SetRnd.cs

@@ -1,5 +1,8 @@
 using System;
 using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -10,61 +13,61 @@ namespace MinecraftClient.Commands
         public override string CmdDesc { get { return Translations.cmd_setrnd_desc; } }
         private static readonly Random rand = new();
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
-            {
-                string[] args = GetArg(command).Split(' ');
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Then(l => l.Literal("range")
+                        .Executes(r => GetUsage(r.Source, "range")))
+                )
+            );
 
-                if (args.Length > 1)
-                {
-                    // detect "to" keyword in string
-                    if (args.Length == 2 && args[1].Contains("to"))
-                    {
-                        int num1;
-                        int num2;
-
-                        // try to extract the two numbers from the string
-                        try
-                        {
-                            num1 = Convert.ToInt32(args[1][..args[1].IndexOf('t')]);
-                            num2 = Convert.ToInt32(args[1].Substring(args[1].IndexOf('o') + 1, args[1].Length - 1 - args[1].IndexOf('o')));
-                        }
-                        catch (Exception)
-                        {
-                            return Translations.cmd_setrndnum_format;
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Argument("VarName", Arguments.String())
+                    .Then(l => l.Argument("Min", Arguments.Long())
+                        .Then(l => l.Literal("to")
+                            .Then(l => l.Argument("Max", Arguments.Long())
+                                .Executes(r => DoSetRnd(r.Source, Arguments.GetString(r, "VarName"), Arguments.GetLong(r, "Min"), Arguments.GetLong(r, "Max"))))))
+                    .Then(l => l.Argument("Expression", Arguments.GreedyString())
+                        .Executes(r => DoSetRnd(r.Source, Arguments.GetString(r, "VarName"), Arguments.GetString(r, "Expression")))))
+            );
         }
 
-                        // switch the values if they were entered in the wrong way
-                        if (num2 < num1)
-                            (num2, num1) = (num1, num2);
-
-                        // create a variable or set it to num1 <= varlue < num2
-                        if (Settings.Config.AppVar.SetVar(args[0], rand.Next(num1, num2)))
+        private int GetUsage(CmdResult r, string? cmd)
         {
-                            return string.Format("Set %{0}% to {1}.", args[0], Settings.Config.AppVar.GetVar(args[0])); //Success
-                        }
-                        else return Translations.cmd_setrndnum_format;
-                    }
-                    else
+            return r.SetAndReturn(cmd switch
             {
-                        // extract all arguments of the command
-                        string argString = command[(8 + command.Split(' ')[1].Length)..];
+#pragma warning disable format // @formatter:off
+                "range"     =>  GetCmdDescTranslated(),
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
 
+        private int DoSetRnd(CmdResult r, string var, string argString)
+        {
             // process all arguments similar to regular terminals with quotes and escaping
             List<string> values = ParseCommandLine(argString);
 
             // create a variable or set it to one of the values
-                        if (values.Count > 0 && Settings.Config.AppVar.SetVar(args[0], values[rand.Next(0, values.Count)]))
+            if (values.Count > 0 && Settings.Config.AppVar.SetVar(var, values[rand.Next(0, values.Count)]))
+                return r.SetAndReturn(CmdResult.Status.Done, string.Format("Set %{0}% to {1}.", var, Settings.Config.AppVar.GetVar(var)));
+            else
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_setrndstr_format);
+        }
+
+        private int DoSetRnd(CmdResult r, string var, long min, long max)
         {
-                            return string.Format("Set %{0}% to {1}.", args[0], Settings.Config.AppVar.GetVar(args[0])); //Success
-                        }
-                        else return Translations.cmd_setrndstr_format;
-                    }
-                }
-                else return GetCmdDescTranslated();
-            }
-            else return GetCmdDescTranslated();
+            // switch the values if they were entered in the wrong way
+            if (max < min)
+                (max, min) = (min, max);
+
+            // create a variable or set it to num1 <= varlue < num2
+            if (Settings.Config.AppVar.SetVar(var, rand.NextInt64(min, max)))
+                return r.SetAndReturn(CmdResult.Status.Fail, string.Format("Set %{0}% to {1}.", var, Settings.Config.AppVar.GetVar(var)));
+            else
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.cmd_setrndstr_format);
         }
     }
 }

MinecraftClient/Commands/Sneak.cs

@@ -1,29 +1,64 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
     public class Sneak : Command
     {
         private bool sneaking = false;
-        public override string CmdName { get { return "Sneak"; } }
-        public override string CmdUsage { get { return "Sneak"; } }
+        public override string CmdName { get { return "sneak"; } }
+        public override string CmdUsage { get { return "sneak"; } }
         public override string CmdDesc { get { return Translations.cmd_sneak_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => DoSneak(r.Source))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoSneak(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
             if (sneaking)
             {
                 var result = handler.SendEntityAction(Protocol.EntityActionType.StopSneaking);
                 if (result)
                     sneaking = false;
-                return result ? Translations.cmd_sneak_off : Translations.general_fail;
+                if (result)
+                    return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_sneak_off);
+                else
+                    return r.SetAndReturn(CmdResult.Status.Fail);
             }
             else
             {
                 var result = handler.SendEntityAction(Protocol.EntityActionType.StartSneaking);
                 if (result)
                     sneaking = true;
-                return result ? Translations.cmd_sneak_on : Translations.general_fail;
+                if (result)
+                    return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_sneak_on);
+                else
+                    return r.SetAndReturn(CmdResult.Status.Fail);
             }
         }
     }

MinecraftClient/Commands/Tps.cs

@@ -1,5 +1,7 @@
 using System;
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -9,8 +11,35 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "tps"; } }
         public override string CmdDesc { get { return Translations.cmd_tps_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => DoLogTps(r.Source))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoLogTps(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
             var tps = Math.Round(handler.GetServerTPS(), 2);
             string color;
             if (tps < 10)
@@ -19,7 +48,7 @@ namespace MinecraftClient.Commands
                 color = "§e";  // Yellow
             else
                 color = "§a"; // Green
-            return Translations.cmd_tps_current + ": " + color + tps;
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.cmd_tps_current + ": " + color + tps);
         }
     }
 }

MinecraftClient/Commands/Upgrade.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 
 namespace MinecraftClient.Commands
 {
@@ -8,45 +10,69 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "upgrade [-f|check|cancel|download]"; } }
         public override string CmdDesc { get { return string.Empty; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (HasArg(command))
-            {
-                string[] args = GetArgs(command);
-                return args[0] switch
-                {
-                    "-f" => DownloadUpdate(force: true),
-                    "-force" => DownloadUpdate(force: true),
-                    "cancel" => CancelDownloadUpdate(),
-                    "check" => CheckUpdate(),
-                    "download" => DownloadUpdate(force: args.Length > 1 && (args[1] == "-f" || args[1] == "-force")),
-                    _ => GetCmdDescTranslated(),
-                };
-            }
-            else
-            {
-                return DownloadUpdate(force: false);
-            }
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Then(l => l.Literal("cancel")
+                        .Executes(r => GetUsage(r.Source, "cancel")))
+                    .Then(l => l.Literal("check")
+                        .Executes(r => GetUsage(r.Source, "check")))
+                    .Then(l => l.Literal("download")
+                        .Executes(r => GetUsage(r.Source, "download")))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => DownloadUpdate(r.Source, force: false))
+                .Then(l => l.Literal("-f")
+                    .Executes(r => DownloadUpdate(r.Source, force: true)))
+                .Then(l => l.Literal("download")
+                    .Executes(r => DownloadUpdate(r.Source, force: false))
+                    .Then(l => l.Literal("-f")
+                        .Executes(r => DownloadUpdate(r.Source, force: true))))
+                .Then(l => l.Literal("check")
+                    .Executes(r => CheckUpdate(r.Source)))
+                .Then(l => l.Literal("cancel")
+                    .Executes(r => CancelDownloadUpdate(r.Source)))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
         }
 
-        private static string DownloadUpdate(bool force)
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                "cancel"    =>  GetCmdDescTranslated(),
+                "check"     =>  GetCmdDescTranslated(),
+                "download"  =>  GetCmdDescTranslated(),
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private static int DownloadUpdate(CmdResult r, bool force)
         {
             if (UpgradeHelper.DownloadLatestBuild(force))
-                return Translations.mcc_update_start;
+                return r.SetAndReturn(CmdResult.Status.Done, Translations.mcc_update_start);
             else
-                return Translations.mcc_update_already_running;
+                return r.SetAndReturn(CmdResult.Status.Fail, Translations.mcc_update_already_running);
         }
 
-        private static string CancelDownloadUpdate()
+        private static int CancelDownloadUpdate(CmdResult r)
         {
             UpgradeHelper.CancelDownloadUpdate();
-            return Translations.mcc_update_cancel;
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.mcc_update_cancel);
         }
 
-        private static string CheckUpdate()
+        private static int CheckUpdate(CmdResult r)
         {
             UpgradeHelper.CheckUpdate(forceUpdate: true);
-            return Translations.mcc_update_start;
+            return r.SetAndReturn(CmdResult.Status.Done, Translations.mcc_update_start);
         }
     }
 }

MinecraftClient/Commands/UseItem.cs

@@ -1,4 +1,7 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
+using static MinecraftClient.CommandHandler.CmdResult;
 
 namespace MinecraftClient.Commands
 {
@@ -8,14 +11,40 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "useitem"; } }
         public override string CmdDesc { get { return Translations.cmd_useitem_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
-            if (handler.GetInventoryEnabled())
-            {
-                handler.UseItemOnHand();
-                return Translations.cmd_useitem_use;
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Executes(r => DoUseItem(r.Source))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
         }
-            else return Translations.extra_inventory_required;
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int DoUseItem(CmdResult r)
+        {
+            McClient handler = CmdResult.currentHandler!;
+            if (!handler.GetInventoryEnabled())
+                return r.SetAndReturn(Status.FailNeedInventory);
+
+            handler.UseItemOnHand();
+            return r.SetAndReturn(Status.Done, Translations.cmd_useitem_use);
         }
     }
 }

MinecraftClient/Commands/Useblock.cs

@@ -1,5 +1,8 @@
-using System.Collections.Generic;
+using Brigadier.NET;
+using Brigadier.NET.Builder;
+using MinecraftClient.CommandHandler;
 using MinecraftClient.Mapping;
+using static MinecraftClient.CommandHandler.CmdResult;
 
 namespace MinecraftClient.Commands
 {
@@ -9,25 +12,44 @@ namespace MinecraftClient.Commands
         public override string CmdUsage { get { return "useblock <x> <y> <z>"; } }
         public override string CmdDesc { get { return Translations.cmd_useblock_desc; } }
 
-        public override string Run(McClient handler, string command, Dictionary<string, object>? localVars)
+        public override void RegisterCommand(CommandDispatcher<CmdResult> dispatcher)
         {
+            dispatcher.Register(l => l.Literal("help")
+                .Then(l => l.Literal(CmdName)
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                )
+            );
+
+            dispatcher.Register(l => l.Literal(CmdName)
+                .Then(l => l.Argument("Location", MccArguments.Location())
+                    .Executes(r => UseBlockAtLocation(r.Source, MccArguments.GetLocation(r, "Location"))))
+                .Then(l => l.Literal("_help")
+                    .Executes(r => GetUsage(r.Source, string.Empty))
+                    .Redirect(dispatcher.GetRoot().GetChild("help").GetChild(CmdName)))
+            );
+        }
+
+        private int GetUsage(CmdResult r, string? cmd)
+        {
+            return r.SetAndReturn(cmd switch
+            {
+#pragma warning disable format // @formatter:off
+                _           =>  GetCmdDescTranslated(),
+#pragma warning restore format // @formatter:on
+            });
+        }
+
+        private int UseBlockAtLocation(CmdResult r, Location block)
+        {
+            McClient handler = CmdResult.currentHandler!;
             if (!handler.GetTerrainEnabled())
-                return Translations.extra_terrainandmovement_required;
-            else if (HasArg(command))
-            {
-                string[] args = GetArgs(command);
-                if (args.Length >= 3)
-                {
-                    Location block = Location.Parse(handler.GetCurrentLocation().ToFloor(), args[0], args[1], args[2]).ToFloor();
+                return r.SetAndReturn(Status.FailNeedTerrain);
+
+            Location current = handler.GetCurrentLocation();
+            block = block.ToAbsolute(current).ToFloor();
             Location blockCenter = block.ToCenter();
             bool res = handler.PlaceBlock(block, Direction.Down);
-                    return string.Format(Translations.cmd_useblock_use, blockCenter.X, blockCenter.Y, blockCenter.Z, res ? "succeeded" : "failed");
-                }
-                else
-                    return GetCmdDescTranslated();
-            }
-            else
-                return GetCmdDescTranslated();
+            return r.SetAndReturn(string.Format(Translations.cmd_useblock_use, blockCenter.X, blockCenter.Y, blockCenter.Z, res ? "succeeded" : "failed"), res);
         }
     }
 }

MinecraftClient/ConsoleIO.cs

@@ -1,6 +1,14 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Brigadier.NET;
+using FuzzySharp;
+using MinecraftClient.CommandHandler;
+using MinecraftClient.Scripting;
+using static MinecraftClient.Settings;
 
 namespace MinecraftClient
 {
@@ -175,15 +183,162 @@ namespace MinecraftClient
 
         #endregion
 
-        public static void AutocompleteHandler(object? sender, ConsoleKey e)
-        {
-            if (e != ConsoleKey.Tab) return;
+        internal static bool AutoCompleteDone = false;
+        internal static string[] AutoCompleteResult = Array.Empty<string>();
 
-            if (autocomplete_engine == null)
+        private static HashSet<string> Commands = new();
+        private static string[] CommandsFromAutoComplete = Array.Empty<string>();
+        private static string[] CommandsFromDeclareCommands = Array.Empty<string>();
+
+        private static Task _latestTask = Task.CompletedTask;
+        private static CancellationTokenSource? _cancellationTokenSource;
+
+        private static void MccAutocompleteHandler(ConsoleInteractive.ConsoleReader.Buffer buffer)
+        {
+            string fullCommand = buffer.Text;
+            if (string.IsNullOrEmpty(fullCommand))
+            {
+                ConsoleInteractive.ConsoleSuggestion.ClearSuggestions();
+                return;
+            }
+
+            var InternalCmdChar = Config.Main.Advanced.InternalCmdChar;
+            if (InternalCmdChar == MainConfigHealper.MainConfig.AdvancedConfig.InternalCmdCharType.none || fullCommand[0] == InternalCmdChar.ToChar())
+            {
+                int offset = InternalCmdChar == MainConfigHealper.MainConfig.AdvancedConfig.InternalCmdCharType.none ? 0 : 1;
+                if (buffer.CursorPosition - offset < 0)
+                {
+                    ConsoleInteractive.ConsoleSuggestion.ClearSuggestions();
+                    return;
+                }
+                _cancellationTokenSource?.Cancel();
+                using var cts = new CancellationTokenSource();
+                _cancellationTokenSource = cts;
+                var previousTask = _latestTask;
+                var newTask = new Task(async () =>
+                {
+                    string command = fullCommand[offset..];
+                    if (command.Length == 0)
+                    {
+                        List<ConsoleInteractive.ConsoleSuggestion.Suggestion> sugList = new();
+
+                        sugList.Add(new("/"));
+
+                        var childs = McClient.dispatcher.GetRoot().Children;
+                        if (childs != null)
+                            foreach (var child in childs)
+                                sugList.Add(new(child.Name));
+
+                        foreach (var cmd in Commands)
+                            sugList.Add(new(cmd));
+
+                        ConsoleInteractive.ConsoleSuggestion.UpdateSuggestions(sugList.ToArray(), new(offset, offset));
+                    }
+                    else if (command.Length > 0 && command[0] == '/' && !command.Contains(' '))
+                    {
+                        var sorted = Process.ExtractSorted(command[1..], Commands);
+                        var sugList = new ConsoleInteractive.ConsoleSuggestion.Suggestion[sorted.Count()];
+
+                        int index = 0;
+                        foreach (var sug in sorted)
+                            sugList[index++] = new(sug.Value);
+                        ConsoleInteractive.ConsoleSuggestion.UpdateSuggestions(sugList, new(offset, offset + command.Length));
+                    }
+                    else
+                    {
+                        CommandDispatcher<CmdResult>? dispatcher = McClient.dispatcher;
+                        if (dispatcher == null)
                             return;
 
-            var buffer = ConsoleInteractive.ConsoleReader.GetBufferContent();
-            autocomplete_engine.AutoComplete(buffer.Text[..buffer.CursorPosition]);
+                        ParseResults<CmdResult> parse = dispatcher.Parse(command, CmdResult.Empty);
+
+                        Brigadier.NET.Suggestion.Suggestions suggestions = await dispatcher.GetCompletionSuggestions(parse, buffer.CursorPosition - offset);
+
+                        int sugLen = suggestions.List.Count;
+                        if (sugLen == 0)
+                        {
+                            ConsoleInteractive.ConsoleSuggestion.ClearSuggestions();
+                            return;
+                        }
+
+                        Dictionary<string, string?> dictionary = new();
+                        foreach (var sug in suggestions.List)
+                            dictionary.Add(sug.Text, sug.Tooltip?.String);
+
+                        var sugList = new ConsoleInteractive.ConsoleSuggestion.Suggestion[sugLen];
+                        if (cts.IsCancellationRequested)
+                            return;
+
+                        Tuple<int, int> range = new(suggestions.Range.Start + offset, suggestions.Range.End + offset);
+                        var sorted = Process.ExtractSorted(fullCommand[range.Item1..range.Item2], dictionary.Keys);
+                        if (cts.IsCancellationRequested)
+                            return;
+
+                        int index = 0;
+                        foreach (var sug in sorted)
+                            sugList[index++] = new(sug.Value, dictionary[sug.Value] ?? string.Empty);
+
+                        ConsoleInteractive.ConsoleSuggestion.UpdateSuggestions(sugList, range);
+                    }
+                }, cts.Token);
+                _latestTask = newTask;
+                try { newTask.Start(); } catch { }
+                if (_cancellationTokenSource == cts) _cancellationTokenSource = null;
+            }
+            else
+            {
+                ConsoleInteractive.ConsoleSuggestion.ClearSuggestions();
+                return;
+            }
+        }
+
+        public static void AutocompleteHandler(object? sender, ConsoleInteractive.ConsoleReader.Buffer buffer)
+        {
+            if (Settings.Config.Console.CommandSuggestion.Enable)
+                MccAutocompleteHandler(buffer);
+        }
+
+        public static void CancelAutocomplete()
+        {
+            _cancellationTokenSource?.Cancel();
+            _latestTask = Task.CompletedTask;
+            ConsoleInteractive.ConsoleSuggestion.ClearSuggestions();
+
+            AutoCompleteDone = false;
+            AutoCompleteResult = Array.Empty<string>();
+            CommandsFromAutoComplete = Array.Empty<string>();
+            CommandsFromDeclareCommands = Array.Empty<string>();
+        }
+
+        private static void MergeCommands()
+        {
+            Commands.Clear();
+            foreach (string cmd in CommandsFromAutoComplete)
+                Commands.Add('/' + cmd);
+            foreach (string cmd in CommandsFromDeclareCommands)
+                Commands.Add('/' + cmd);
+        }
+
+        public static void OnAutoCompleteDone(int transactionId, string[] result)
+        {
+            AutoCompleteResult = result;
+            if (transactionId == 0)
+            {
+                CommandsFromAutoComplete = result;
+                MergeCommands();
+            }
+            AutoCompleteDone = true;
+        }
+
+        public static void OnDeclareMinecraftCommand(string[] rootCommands)
+        {
+            CommandsFromDeclareCommands = rootCommands;
+            MergeCommands();
+        }
+
+        public static void InitCommandList(CommandDispatcher<CmdResult> dispatcher)
+        {
+            autocomplete_engine!.AutoComplete("/");
         }
     }
 
@@ -198,6 +353,6 @@ namespace MinecraftClient
         /// </summary>
         /// <param name="BehindCursor">Text behind the cursor, e.g. "my input comm"</param>
         /// <returns>List of auto-complete words, e.g. ["command", "comment"]</returns>
-        IEnumerable<string> AutoComplete(string BehindCursor);
+        int AutoComplete(string BehindCursor);
     }
 }

MinecraftClient/Crypto/AesCfb8Stream.cs

@@ -1,15 +1,13 @@
 using System;
-using System.Collections.Concurrent;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Security.Cryptography;
-using System.Threading.Tasks;
 
 namespace MinecraftClient.Crypto
 {
     public class AesCfb8Stream : Stream
     {
-        public static readonly int blockSize = 16;
+        public const int blockSize = 16;
 
         private readonly Aes? Aes = null;
         private readonly FastAes? FastAes = null;
@@ -109,7 +107,7 @@ namespace MinecraftClient.Crypto
             if (inStreamEnded)
                 return 0;
 
-            Span<byte> blockOutput = FastAes != null ? stackalloc byte[blockSize] : null;
+            Span<byte> blockOutput = stackalloc byte[blockSize];
 
             byte[] inputBuf = new byte[blockSize + required];
             Array.Copy(ReadStreamIV, inputBuf, blockSize);
@@ -135,18 +133,12 @@ namespace MinecraftClient.Crypto
                 }
                 else
                 {
-                    OrderablePartitioner<Tuple<int, int>> rangePartitioner = curRead <= 256 ?
-                        Partitioner.Create(readed, processEnd, 32) : Partitioner.Create(readed, processEnd);
-                    Parallel.ForEach(rangePartitioner, (range, loopState) =>
-                    {
-                        Span<byte> blockOutput = stackalloc byte[blockSize];
-                        for (int idx = range.Item1; idx < range.Item2; idx++)
+                    for (int idx = readed; idx < processEnd; idx++)
                     {
                         ReadOnlySpan<byte> blockInput = new(inputBuf, idx, blockSize);
                         Aes!.EncryptEcb(blockInput, blockOutput, PaddingMode.None);
                         buffer[outOffset + idx] = (byte)(blockOutput[0] ^ inputBuf[idx + blockSize]);
                     }
-                    });
                 }
             }
 

MinecraftClient/Inventory/EnchantmentMapping.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using MinecraftClient.Protocol.Handlers;
+using MinecraftClient.Protocol.Message;
 
 namespace MinecraftClient.Inventory
 {
@@ -158,7 +159,7 @@ namespace MinecraftClient.Inventory
 
         public static string GetEnchantmentName(Enchantment enchantment)
         {
-            string? trans = Protocol.ChatParser.TranslateString("enchantment.minecraft." + enchantment.ToString().ToUnderscoreCase());
+            string? trans = ChatParser.TranslateString("enchantment.minecraft." + enchantment.ToString().ToUnderscoreCase());
             if (string.IsNullOrEmpty(trans))
                 return "Unknown Enchantment with ID: " + ((short)enchantment) + " (Probably not named in the code yet)";
             else

MinecraftClient/Inventory/Item.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Text;
+using MinecraftClient.Protocol.Message;
 
 namespace MinecraftClient.Inventory
 {
@@ -64,7 +65,7 @@ namespace MinecraftClient.Inventory
                     {
                         string? displayName = displayProperties["Name"] as string;
                         if (!String.IsNullOrEmpty(displayName))
-                            return MinecraftClient.Protocol.ChatParser.ParseText(displayProperties["Name"].ToString() ?? string.Empty);
+                            return ChatParser.ParseText(displayProperties["Name"].ToString() ?? string.Empty);
                     }
                 }
                 return null;
@@ -85,7 +86,7 @@ namespace MinecraftClient.Inventory
                     {
                         object[] displayName = (object[])displayProperties["Lore"];
                         lores.AddRange(from string st in displayName
-                                       let str = MinecraftClient.Protocol.ChatParser.ParseText(st.ToString())
+                                       let str = ChatParser.ParseText(st.ToString())
                                        select str);
                         return lores.ToArray();
                     }
@@ -117,10 +118,10 @@ namespace MinecraftClient.Inventory
         {
             string type_str = type.ToString();
             string type_renamed = type_str.ToUnderscoreCase();
-            string? res1 = Protocol.ChatParser.TranslateString("item.minecraft." + type_renamed);
+            string? res1 = ChatParser.TranslateString("item.minecraft." + type_renamed);
             if (!string.IsNullOrEmpty(res1))
                 return res1;
-            string? res2 = Protocol.ChatParser.TranslateString("block.minecraft." + type_renamed);
+            string? res2 = ChatParser.TranslateString("block.minecraft." + type_renamed);
             if (!string.IsNullOrEmpty(res2))
                 return res2;
             return type_str;
@@ -145,8 +146,8 @@ namespace MinecraftClient.Inventory
                         short level = (short)enchantment["lvl"];
                         string id = ((string)enchantment["id"]).Replace(':', '.');
                         sb.AppendFormat(" | {0} {1}",
-                                        Protocol.ChatParser.TranslateString("enchantment." + id) ?? id,
-                                        Protocol.ChatParser.TranslateString("enchantment.level." + level) ?? level.ToString());
+                                        ChatParser.TranslateString("enchantment." + id) ?? id,
+                                        ChatParser.TranslateString("enchantment.level." + level) ?? level.ToString());
                     }
                 }
             }

MinecraftClient/Inventory/ItemMovingHelper.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using MinecraftClient.Scripting;
 
 namespace MinecraftClient.Inventory
 {

MinecraftClient/Inventory/ItemType.cs

@@ -20,6 +20,7 @@
         AcaciaDoor,
         AcaciaFence,
         AcaciaFenceGate,
+        AcaciaHangingSign,
         AcaciaLeaves,
         AcaciaLog,
         AcaciaPlanks,
@@ -53,6 +54,23 @@
         AzureBluet,
         BakedPotato,
         Bamboo,
+        BambooBlock,
+        BambooButton,
+        BambooChestRaft,
+        BambooDoor,
+        BambooFence,
+        BambooFenceGate,
+        BambooHangingSign,
+        BambooMosaic,
+        BambooMosaicSlab,
+        BambooMosaicStairs,
+        BambooPlanks,
+        BambooPressurePlate,
+        BambooRaft,
+        BambooSign,
+        BambooSlab,
+        BambooStairs,
+        BambooTrapdoor,
         Barrel,
         Barrier,
         Basalt,
@@ -74,6 +92,7 @@
         BirchDoor,
         BirchFence,
         BirchFenceGate,
+        BirchHangingSign,
         BirchLeaves,
         BirchLog,
         BirchPlanks,
@@ -161,6 +180,7 @@
         Cactus,
         Cake,
         Calcite,
+        CamelSpawnEgg,
         Campfire,
         Candle,
         Carrot,
@@ -182,6 +202,7 @@
         Chicken,
         ChickenSpawnEgg,
         ChippedAnvil,
+        ChiseledBookshelf,
         ChiseledDeepslate,
         ChiseledNetherBricks,
         ChiseledPolishedBlackstone,
@@ -245,6 +266,7 @@
         CrimsonFence,
         CrimsonFenceGate,
         CrimsonFungus,
+        CrimsonHangingSign,
         CrimsonHyphae,
         CrimsonNylium,
         CrimsonPlanks,
@@ -285,6 +307,7 @@
         DarkOakDoor,
         DarkOakFence,
         DarkOakFenceGate,
+        DarkOakHangingSign,
         DarkOakLeaves,
         DarkOakLog,
         DarkOakPlanks,
@@ -384,6 +407,7 @@
         EndStoneBrickWall,
         EndStoneBricks,
         EnderChest,
+        EnderDragonSpawnEgg,
         EnderEye,
         EnderPearl,
         EndermanSpawnEgg,
@@ -518,6 +542,7 @@
         IronBoots,
         IronChestplate,
         IronDoor,
+        IronGolemSpawnEgg,
         IronHelmet,
         IronHoe,
         IronHorseArmor,
@@ -539,6 +564,7 @@
         JungleDoor,
         JungleFence,
         JungleFenceGate,
+        JungleHangingSign,
         JungleLeaves,
         JungleLog,
         JunglePlanks,
@@ -639,6 +665,7 @@
         MangroveDoor,
         MangroveFence,
         MangroveFenceGate,
+        MangroveHangingSign,
         MangroveLeaves,
         MangroveLog,
         MangrovePlanks,
@@ -729,6 +756,7 @@
         OakDoor,
         OakFence,
         OakFenceGate,
+        OakHangingSign,
         OakLeaves,
         OakLog,
         OakPlanks,
@@ -776,6 +804,7 @@
         PigSpawnEgg,
         PiglinBannerPattern,
         PiglinBruteSpawnEgg,
+        PiglinHead,
         PiglinSpawnEgg,
         PillagerSpawnEgg,
         PinkBanner,
@@ -970,6 +999,7 @@
         SmoothStoneSlab,
         Snow,
         SnowBlock,
+        SnowGolemSpawnEgg,
         Snowball,
         SoulCampfire,
         SoulLantern,
@@ -989,6 +1019,7 @@
         SpruceDoor,
         SpruceFence,
         SpruceFenceGate,
+        SpruceHangingSign,
         SpruceLeaves,
         SpruceLog,
         SprucePlanks,
@@ -1023,6 +1054,7 @@
         String,
         StrippedAcaciaLog,
         StrippedAcaciaWood,
+        StrippedBambooBlock,
         StrippedBirchLog,
         StrippedBirchWood,
         StrippedCrimsonHyphae,
@@ -1085,6 +1117,7 @@
         WarpedFenceGate,
         WarpedFungus,
         WarpedFungusOnAStick,
+        WarpedHangingSign,
         WarpedHyphae,
         WarpedNylium,
         WarpedPlanks,
@@ -1139,6 +1172,7 @@
         WitherRose,
         WitherSkeletonSkull,
         WitherSkeletonSpawnEgg,
+        WitherSpawnEgg,
         WolfSpawnEgg,
         WoodenAxe,
         WoodenHoe,

MinecraftClient/Inventory/VillagerInfo.cs

@@ -1,4 +1,4 @@
-namespace MinecraftClient.Mapping
+namespace MinecraftClient.Inventory
 {
     /// <summary>
     /// Properties of a villager

MinecraftClient/Logger/FileLogLogger.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using MinecraftClient.Scripting;
 
 namespace MinecraftClient.Logger
 {

MinecraftClient/Mapping/Block.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Runtime.CompilerServices;
 using MinecraftClient.Mapping.BlockPalettes;
+using MinecraftClient.Protocol.Message;
 
 namespace MinecraftClient.Mapping
 {
@@ -115,7 +116,7 @@ namespace MinecraftClient.Mapping
         public string GetTypeString()
         {
             string typeStr = Type.ToString();
-            string? trans = Protocol.ChatParser.TranslateString("block.minecraft." + typeStr.ToUnderscoreCase());
+            string? trans = ChatParser.TranslateString("block.minecraft." + typeStr.ToUnderscoreCase());
             return string.IsNullOrEmpty(trans) ? typeStr : trans;
         }
 

MinecraftClient/Mapping/Entity.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using MinecraftClient.Inventory;
+using MinecraftClient.Protocol.Message;
 
 namespace MinecraftClient.Mapping
 {
@@ -155,11 +156,16 @@ namespace MinecraftClient.Mapping
             Pitch = pitch * (1F / 256) * 360;
         }
 
+        public static string GetTypeString(EntityType type)
+        {
+            string typeStr = type.ToString();
+            string? trans = ChatParser.TranslateString("entity.minecraft." + typeStr.ToUnderscoreCase());
+            return string.IsNullOrEmpty(trans) ? typeStr : trans;
+        }
+
         public string GetTypeString()
         {
-            string typeStr = Type.ToString();
-            string? trans = Protocol.ChatParser.TranslateString("entity.minecraft." + typeStr.ToUnderscoreCase());
-            return string.IsNullOrEmpty(trans) ? typeStr : trans;
+            return GetTypeString(Type);
         }
     }
 }

MinecraftClient/Mapping/EntityPalettes/EntityPalette1193.cs

@@ -0,0 +1,137 @@
+using System.Collections.Generic;
+
+namespace MinecraftClient.Mapping.EntityPalettes
+{
+    public class EntityPalette1193 : EntityPalette
+    {
+        private static readonly Dictionary<int, EntityType> mappings = new();
+
+        static EntityPalette1193()
+        {
+            mappings[0] = EntityType.Allay;
+            mappings[1] = EntityType.AreaEffectCloud;
+            mappings[2] = EntityType.ArmorStand;
+            mappings[3] = EntityType.Arrow;
+            mappings[4] = EntityType.Axolotl;
+            mappings[5] = EntityType.Bat;
+            mappings[6] = EntityType.Bee;
+            mappings[7] = EntityType.Blaze;
+            mappings[8] = EntityType.Boat;
+            mappings[11] = EntityType.Camel;
+            mappings[10] = EntityType.Cat;
+            mappings[12] = EntityType.CaveSpider;
+            mappings[9] = EntityType.ChestBoat;
+            mappings[55] = EntityType.ChestMinecart;
+            mappings[13] = EntityType.Chicken;
+            mappings[14] = EntityType.Cod;
+            mappings[56] = EntityType.CommandBlockMinecart;
+            mappings[15] = EntityType.Cow;
+            mappings[16] = EntityType.Creeper;
+            mappings[17] = EntityType.Dolphin;
+            mappings[18] = EntityType.Donkey;
+            mappings[19] = EntityType.DragonFireball;
+            mappings[20] = EntityType.Drowned;
+            mappings[94] = EntityType.Egg;
+            mappings[21] = EntityType.ElderGuardian;
+            mappings[22] = EntityType.EndCrystal;
+            mappings[23] = EntityType.EnderDragon;
+            mappings[95] = EntityType.EnderPearl;
+            mappings[24] = EntityType.Enderman;
+            mappings[25] = EntityType.Endermite;
+            mappings[26] = EntityType.Evoker;
+            mappings[27] = EntityType.EvokerFangs;
+            mappings[96] = EntityType.ExperienceBottle;
+            mappings[28] = EntityType.ExperienceOrb;
+            mappings[29] = EntityType.EyeOfEnder;
+            mappings[30] = EntityType.FallingBlock;
+            mappings[47] = EntityType.Fireball;
+            mappings[31] = EntityType.FireworkRocket;
+            mappings[118] = EntityType.FishingBobber;
+            mappings[32] = EntityType.Fox;
+            mappings[33] = EntityType.Frog;
+            mappings[57] = EntityType.FurnaceMinecart;
+            mappings[34] = EntityType.Ghast;
+            mappings[35] = EntityType.Giant;
+            mappings[36] = EntityType.GlowItemFrame;
+            mappings[37] = EntityType.GlowSquid;
+            mappings[38] = EntityType.Goat;
+            mappings[39] = EntityType.Guardian;
+            mappings[40] = EntityType.Hoglin;
+            mappings[58] = EntityType.HopperMinecart;
+            mappings[41] = EntityType.Horse;
+            mappings[42] = EntityType.Husk;
+            mappings[43] = EntityType.Illusioner;
+            mappings[44] = EntityType.IronGolem;
+            mappings[45] = EntityType.Item;
+            mappings[46] = EntityType.ItemFrame;
+            mappings[48] = EntityType.LeashKnot;
+            mappings[49] = EntityType.LightningBolt;
+            mappings[50] = EntityType.Llama;
+            mappings[51] = EntityType.LlamaSpit;
+            mappings[52] = EntityType.MagmaCube;
+            mappings[53] = EntityType.Marker;
+            mappings[54] = EntityType.Minecart;
+            mappings[62] = EntityType.Mooshroom;
+            mappings[61] = EntityType.Mule;
+            mappings[63] = EntityType.Ocelot;
+            mappings[64] = EntityType.Painting;
+            mappings[65] = EntityType.Panda;
+            mappings[66] = EntityType.Parrot;
+            mappings[67] = EntityType.Phantom;
+            mappings[68] = EntityType.Pig;
+            mappings[69] = EntityType.Piglin;
+            mappings[70] = EntityType.PiglinBrute;
+            mappings[71] = EntityType.Pillager;
+            mappings[117] = EntityType.Player;
+            mappings[72] = EntityType.PolarBear;
+            mappings[97] = EntityType.Potion;
+            mappings[74] = EntityType.Pufferfish;
+            mappings[75] = EntityType.Rabbit;
+            mappings[76] = EntityType.Ravager;
+            mappings[77] = EntityType.Salmon;
+            mappings[78] = EntityType.Sheep;
+            mappings[79] = EntityType.Shulker;
+            mappings[80] = EntityType.ShulkerBullet;
+            mappings[81] = EntityType.Silverfish;
+            mappings[82] = EntityType.Skeleton;
+            mappings[83] = EntityType.SkeletonHorse;
+            mappings[84] = EntityType.Slime;
+            mappings[85] = EntityType.SmallFireball;
+            mappings[86] = EntityType.SnowGolem;
+            mappings[87] = EntityType.Snowball;
+            mappings[59] = EntityType.SpawnerMinecart;
+            mappings[88] = EntityType.SpectralArrow;
+            mappings[89] = EntityType.Spider;
+            mappings[90] = EntityType.Squid;
+            mappings[91] = EntityType.Stray;
+            mappings[92] = EntityType.Strider;
+            mappings[93] = EntityType.Tadpole;
+            mappings[73] = EntityType.Tnt;
+            mappings[60] = EntityType.TntMinecart;
+            mappings[99] = EntityType.TraderLlama;
+            mappings[98] = EntityType.Trident;
+            mappings[100] = EntityType.TropicalFish;
+            mappings[101] = EntityType.Turtle;
+            mappings[102] = EntityType.Vex;
+            mappings[103] = EntityType.Villager;
+            mappings[104] = EntityType.Vindicator;
+            mappings[105] = EntityType.WanderingTrader;
+            mappings[106] = EntityType.Warden;
+            mappings[107] = EntityType.Witch;
+            mappings[108] = EntityType.Wither;
+            mappings[109] = EntityType.WitherSkeleton;
+            mappings[110] = EntityType.WitherSkull;
+            mappings[111] = EntityType.Wolf;
+            mappings[112] = EntityType.Zoglin;
+            mappings[113] = EntityType.Zombie;
+            mappings[114] = EntityType.ZombieHorse;
+            mappings[115] = EntityType.ZombieVillager;
+            mappings[116] = EntityType.ZombifiedPiglin;
+        }
+
+        protected override Dictionary<int, EntityType> GetDict()
+        {
+            return mappings;
+        }
+    }
+}