Fabric Wiki

User Tools

Site Tools

Trace:
tutorial:commands

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
Next revisionBoth sides next revision
tutorial:commands [2019/07/29 19:03] – Removed references to internals pyrofabtutorial:commands [2020/05/16 01:57] – Reword some parts of the tutorial, includes a few gramatical corrections i509vcb
Line 1: Line 1:
 ====== Creating Commands ====== ====== Creating Commands ======
  
-Creating commands can allow a mod developer to add functionality a player can run a command to use.  +Creating commands can allow a mod developer to add functionality that a player can use through a command.  
-This tutorial will teach you how to register commands, and the command structure of Brigadier along with some more advanced commands structures.+This tutorial will teach you how to register commands, and the command structure of Brigadier. 
 + 
 +Note: All code written here was written for 1.14.4. Some mappings may have changed in yarn, but all code should still be applicable.
  
 ===== Registering Commands ===== ===== Registering Commands =====
  
-If you just want to see how to register commands you've come to the right place here. +Registering commands is done by registering a new listener in the ''CommandRegistrationCallback''. 
- +The event should be registered in your mod's initializer.
-Registering commands is done through ''CommandRegistry'' through the ''register'' method. +
- +
-The register method specifies two arguments, the dedicated flag and a consumer representing the CommandDispatcher. These methods should be placed in your mod's initalizer. +
- +
-The dedicated flag if set to true will tell Fabric to only register the command on a DedicatedServer (if false than the command will register on both the InternalServer and DedicatedServer).+
  
 +The dedicated parameter if true will tell event listeners that the server commands are being registered on is a ''dedicated server''. If false than the commands will registered on an ''integrated server''.
 Below are a few examples of how the commands can be registered. Below are a few examples of how the commands can be registered.
  
-<code java> +<code java [enable_line_numbers="true"]> 
-CommandRegistry.INSTANCE.register(false, dispatcher -> TutorialCommands.register(dispatcher)); // All commands are registered in a single class that references every command. +// Method reference 
-  +CommandRegistrationCallback.EVENT.register(TutorialCommands::register); 
-CommandRegistry.INSTANCE.register(false, dispatcher -> { // You can also just reference every single class also. There is also the alternative of just using CommandRegistry+ 
 +// Using a lambda 
 +CommandRegistrationCallback.EVENT.register((dispatcher, dedicated) -> { 
 +    // This command will be registered regardless of the server being dedicated or integrated
     TutorialCommand.register(dispatcher);     TutorialCommand.register(dispatcher);
-    TutorialHelpCommand.register(dispatcher);+    if (dedicated) { 
 +        // This command will only be registered on a dedicated server 
 +        TutorialHelpCommand.register(dispatcher); 
 +    } else { 
 +        // This command will only be registered on an integrated server. 
 +        // Commands which call client only classes and methods should be registered in your ClientModInitializer 
 +        IntegratedTutorialHelpCommand.register(dispatcher);  
 +    }
 }); });
-  + 
-CommandRegistry.INSTANCE.register(true, dispatcher -> { // Or directly registering the command to the dispatcher. +// Or register directly 
- dispatcher.register(LiteralArgumentBuilder.literal("tutorial").executes(ctx -> execute(ctx)));+CommandRegistrationCallback.EVENT.register((dispatcher, dedicated) -> { 
 +    dispatcher.register(LiteralArgumentBuilder.literal("tutorial").executes(ctx -> execute(ctx)));
 }); });
 </code> </code>
Line 33: Line 42:
 Wait isn't this the exact same command from the Brigadier tutorial? Well yes it is but it is here to help explain the structure of a command. Wait isn't this the exact same command from the Brigadier tutorial? Well yes it is but it is here to help explain the structure of a command.
  
-<code java>+<code java [enable_line_numbers="true"]>
 // The root of the command. This must be a literal argument. // The root of the command. This must be a literal argument.
-dispatcher.register(LiteralArgumentBuilder.literal("foo") +dispatcher.register(CommandManager.literal("foo") 
 // Then add an argument named bar that is an integer // Then add an argument named bar that is an integer
-    .then(RequiredArgumentBuilder.argument("bar", integer()) +    .then(CommandManager.argument("bar", integer()) 
- // The command to be executed if the command "foo" is entered with the argument "bar"+        // The command to be executed if the command "foo" is entered with the argument "bar"
         .executes(ctx -> {          .executes(ctx -> { 
             System.out.println("Bar is " + IntArgumentType.getInteger(ctx, "bar"));             System.out.println("Bar is " + IntArgumentType.getInteger(ctx, "bar"));
-     // Return a result. -1 is failure, 0 is a pass and 1 is success.+            // Return a result. Typically -1 is failure, 0 is pass and 1 is success.
             return 1;             return 1;
-            }))+        }))
     // The command "foo" to execute if there are no arguments.     // The command "foo" to execute if there are no arguments.
     .executes(ctx -> {      .executes(ctx -> { 
Line 52: Line 61:
 </code> </code>
  
-The main process registers the command "foo" (Root Node) with an optional argument of "bar" (Child node).  +The main process registers the command ''foo'' (Root Node) with an optional argument of ''bar'' (Child node).  
-Since the root node must be literal, The sender must enter the exact same sequence of letters to execute the command, so "Foo", "fOo" or "fooo" will not execute the command.+Since the root node must be literal, The sender must enter the exact same sequence of letters to execute the command, so ''Foo'', ''fOo'' or ''fooo'' will not execute the command.
  
 ===== Brigadier Explained ===== ===== Brigadier Explained =====
  
-Brigadier starts with the ''CommandDispatcher'' which should be thought more as a tree rather than a list of methods.  +Brigadier starts with the ''CommandDispatcher'' which should be thought more as a tree of command nodes. 
-The trunk of the tree is the CommandDispatcher.  + 
-The register(LiteralArgumentBuilder) methods specify the beginning of branches with the following then methods specifying the shape of length of the branches.  +Command nodes are similar to the branches that define the command tree. The executes blocks can be seen at the leaves of the tree where a branch ends and also supplies the command to be executed.
-The executes blocks can be seen at the leaves of the tree where it ends and also supplies the outcome of the system.+
  
-The execute blocks specify the command to be ran. As Brigadier's Command is a FunctionalInterface you can use lambdas to specify commands.+The execute blocks specify the command to be ran. As Brigadier's Command is a functional interface you can use lambdas to specify commands.
  
 ==== CommandContexts ==== ==== CommandContexts ====
  
-When a command is ran, Brigadier provides a CommandContext to the command that is ran. +When a command is ran, Brigadier provides a ''CommandContext'' to the command that is ran. 
 The CommandContext contains all arguments and other objects such as the inputted String and the ''Command Source'' (ServerCommandSource in Minecraft's implementation). The CommandContext contains all arguments and other objects such as the inputted String and the ''Command Source'' (ServerCommandSource in Minecraft's implementation).
  
 ==== Arguments ==== ==== Arguments ====
  
-The arguments in Brigadier both parse and error check any inputted arguments.  +Arguments in Brigadier both parse and error check any inputted arguments. 
-Minecraft creates some special arguments for it's own use such as the ''EntityArgumentType'' which represents the in-game entity selectors ''@a, @r, @p, @e[type=!player, limit=1, distance=..2]'', or an ''NBTTagArgumentType'' that parses NBT and verifies that the input is the correct syntax.+Minecraft creates some special argument types for it's own use such as the ''EntityArgumentType'' which represents the in-game entity selectors ''@a, @r, @p, @e[type=!player, limit=1, distance=..2]'', or an ''NbtTagArgumentType'' that parses stringified nbt (snbt) and verifies that the input is the correct syntax.
  
 +==== Static Imports ====
 You could do the long method of typing ''CommandManager.literal("foo")'' and it would work, but you can statically import the arguments and shorten that to ''literal("foo")''.  You could do the long method of typing ''CommandManager.literal("foo")'' and it would work, but you can statically import the arguments and shorten that to ''literal("foo")''. 
 This also works for getting arguments, which shortens the already long ''StringArgumentType.getString(ctx, "string")'' to ''getString(ctx, "string")''. This also works for getting arguments, which shortens the already long ''StringArgumentType.getString(ctx, "string")'' to ''getString(ctx, "string")''.
Line 79: Line 88:
  
 And your imports would look something like this: And your imports would look something like this:
-<code java>+<code java [enable_line_numbers="true"]>
 import static com.mojang.brigadier.arguments.StringArgumentType.getString; // getString(ctx, "string") import static com.mojang.brigadier.arguments.StringArgumentType.getString; // getString(ctx, "string")
 import static com.mojang.brigadier.arguments.StringArgumentType.word; // word(), string(), greedyString() import static com.mojang.brigadier.arguments.StringArgumentType.word; // word(), string(), greedyString()
Line 86: Line 95:
 import static net.minecraft.server.command.CommandManager.*; // Import everything import static net.minecraft.server.command.CommandManager.*; // Import everything
 </code> </code>
 +
 +Note: Please be sure you use the ''literal'' and ''argument'' from CommandManager or you may have issues with generics.
  
 Brigadier's default arguments are located in ''com.mojang.brigadier.arguments'' Brigadier's default arguments are located in ''com.mojang.brigadier.arguments''
Line 101: Line 112:
 </code> </code>
  
-Loot tables specify their own SuggestionProvider inside LootCommand for example.+Loot tables specify their own SuggestionProvider inside ''LootCommand'' for example.
  
 The example below is a dynamically changing SuggestionProvider that lists several words for a StringArgumentType to demonstrate how it works: The example below is a dynamically changing SuggestionProvider that lists several words for a StringArgumentType to demonstrate how it works:
-<code java>+<code java [enable_line_numbers="true"]>
 public static SuggestionProvider<ServerCommandSource> suggestedStrings() { public static SuggestionProvider<ServerCommandSource> suggestedStrings() {
     return (ctx, builder) -> getSuggestionsBuilder(builder, /*Access to a list here*/);     return (ctx, builder) -> getSuggestionsBuilder(builder, /*Access to a list here*/);
Line 125: Line 136:
 </code> </code>
  
-The SuggestionProvider is a FunctionalInterface that returns a CompletableFuture containing a list of suggestions. These suggestions are given to client as a command is typed and can be changed while server is running. The SuggestionProvider provides a CommandContext and a SuggestionBuilder to determine all the suggestions. The CommandSource can also be taken into account during the suggestion creation process as it is available through the CommandContext.+The SuggestionProvider is a functional interface that returns a CompletableFuture containing a list of suggestions. These suggestions are sent to client as a command is typed and can be changed while server is running. The SuggestionProvider provides a CommandContext and a SuggestionBuilder to allow determination of all the suggestions. The CommandSource can also be taken into account during the suggestion creation process as it is available through the CommandContext.
  
-Though remember these are suggestions. The inputted command may not contain an argument you suggested so you still have to parse check inside the command to see if the argument is what you want if it's a String for example and parsers may still throw exceptions if an invalid syntax is inputted.+Though remember these are suggestions. The inputted command may not contain an argument you suggested so arguments are parsed without consideration for suggestions.
  
-To use the suggestion you would append it right after the argument you want to recommend arguments for. This can be any argument and the normal client side exception popups will still work. Note this cannot be applied to literals.+To use the suggestion you would append it right after the argument you want to suggest possible arguments for. This can be any argument and the normal client side exception popups will still work. Note this cannot be applied to literals.
  
-<code java>+<code java [enable_line_numbers="true"]>
 argument(argumentName, word()) argument(argumentName, word())
 .suggests(CompletionProviders.suggestedStrings()) .suggests(CompletionProviders.suggestedStrings())
Line 137: Line 148:
 </code> </code>
  
-==== Requires ====+==== Requiring Permissions ====
  
 Lets say you have a command you only want operators to be able to execute. This is where the ''requires'' method comes into play. The requires method has one argument of a Predicate<ServerCommandSource> which will supply a ServerCommandSource to test with and determine if the CommandSource can execute the command. Lets say you have a command you only want operators to be able to execute. This is where the ''requires'' method comes into play. The requires method has one argument of a Predicate<ServerCommandSource> which will supply a ServerCommandSource to test with and determine if the CommandSource can execute the command.
Line 143: Line 154:
 For example this may look like the following: For example this may look like the following:
  
-<code java>+<code java [enable_line_numbers="true"]>
 dispatcher.register(literal("foo") dispatcher.register(literal("foo")
  .requires(source -> source.hasPermissionLevel(4))  .requires(source -> source.hasPermissionLevel(4))
Line 153: Line 164:
  
 This command will only execute if the Source of the command is a level 4 operator at minimum. If the predicate returns false, then the command will not execute. Also this has the side effect of not showing this command in tab completion to anyone who is not a level 4 operator. This command will only execute if the Source of the command is a level 4 operator at minimum. If the predicate returns false, then the command will not execute. Also this has the side effect of not showing this command in tab completion to anyone who is not a level 4 operator.
 +
 +Nothing prevents someone from specifying calls to permissions implementations within the ''requires'' block. Just note that if permissions change, you need to re send the command tree.
  
 ==== Exceptions ==== ==== Exceptions ====
  
-Brigadier supports command exceptions which can be used to end a command such as if an argument didn't parse properly or the command failed to execute. +Brigadier supports command exceptions which can be used to end a command such as if an argument didn't parse properly or the command failed to execute, as well as including richer details of the failure.
  
-All the exceptions from Brigadier are based on the CommandSyntaxException. The two main types of exceptions Brigadier provides are Dynamic and Simple exception types, of which you must ''create()'' the exception to throw it. These exceptions also allow you to specify the context in which the exception was thrown using ''createWithContext(ImmutableStringReader)''. Though this can only be used with a custom parser. These can be defined and thrown under certain scenarios during the command. +All the exceptions from Brigadier are based on the CommandSyntaxException. The two main types of exceptions Brigadier provides are Dynamic and Simple exception types, of which you must ''create()'' the exception to throw it. These exceptions also allow you to specify the context in which the exception was thrown using ''createWithContext(ImmutableStringReader)'', which builds the error message to point to where on the inputted command line the error occured.
 Below is a coin flip command to show an example of exceptions in use. Below is a coin flip command to show an example of exceptions in use.
  
-<code java>+<code java [enable_line_numbers="true"]>
 dispatcher.register(CommandManager.literal("coinflip") dispatcher.register(CommandManager.literal("coinflip")
- .executes(ctx -> { +    .executes(ctx -> { 
- Random random = new Random();+        Random random = new Random();
   
- if(random.nextBoolean()) { // If heads succeed. +        if(random.nextBoolean()) { // If heads succeed. 
- ctx.getSource().sendMessage(new TranslateableText("coin.flip.heads")) +            ctx.getSource().sendMessage(new TranslateableText("coin.flip.heads")) 
- return Command.SINGLE_SUCCESS; +            return Command.SINGLE_SUCCESS; 
- } +        } 
- throw new SimpleCommandExceptionType(new TranslateableText("coin.flip.tails")).create(); // Oh no tails, you lose. + 
- }));+        throw new SimpleCommandExceptionType(new TranslateableText("coin.flip.tails")).create(); // Oh no tails, you lose. 
 +    }));
 </code> </code>
  
-Though you are not just limited to a single type of exception as Brigadier also supplies Dynamic exceptions.+Though you are not just limited to a single type of exception as Brigadier also supplies Dynamic exceptions which take additional parameters for context.
  
-<code java>+<code java [enable_line_numbers="true"]>
 DynamicCommandExceptionType used_name = new DynamicCommandExceptionType(name -> { DynamicCommandExceptionType used_name = new DynamicCommandExceptionType(name -> {
- return new LiteralText("The name: " + (String) name + " has been used");+    return new LiteralText("The name: " + (String) name + " has been used");
 }); });
 </code> </code>
Line 189: Line 203:
 Redirects are Brigadier's form of aliases. Below is how Minecraft handles /msg have an alias of /tell and /w.  Redirects are Brigadier's form of aliases. Below is how Minecraft handles /msg have an alias of /tell and /w. 
  
-<code java>+<code java [enable_line_numbers="true"]>
 public static void register(CommandDispatcher<ServerCommandSource> dispatcher) { public static void register(CommandDispatcher<ServerCommandSource> dispatcher) {
     LiteralCommandNode node = registerMain(dispatcher); // Registers main command     LiteralCommandNode node = registerMain(dispatcher); // Registers main command
     dispatcher.register(literal("tell")     dispatcher.register(literal("tell")
- .redirect(node)); // Alias 1, redirect to main command+        .redirect(node)); // Alias 1, redirect to main command
     dispatcher.register(literal("w")     dispatcher.register(literal("w")
- .redirect(node)); // Alias 2, redirect to main command+        .redirect(node)); // Alias 2, redirect to main command
 } }
  
 public static LiteralCommandNode registerMain(CommandDispatcher<ServerCommandSource> dispatcher) { public static LiteralCommandNode registerMain(CommandDispatcher<ServerCommandSource> dispatcher) {
     return dispatcher.register(literal("msg")     return dispatcher.register(literal("msg")
- .then(argument("targets", EntityArgumentType.players()) +    .then(argument("targets", EntityArgumentType.players()) 
-     .then(argument("message", MessageArgumentType.message()) +        .then(argument("message", MessageArgumentType.message()) 
- .executes(ctx -> { +            .executes(ctx -> { 
-     return execute(ctx.getSource(), getPlayers(ctx, "targets"), getMessage(ctx, "message")); +                return execute(ctx.getSource(), getPlayers(ctx, "targets"), getMessage(ctx, "message")); 
- }))));+            }))));
 } }
 </code> </code>
  
-The redirect registers a branch into the command tree, where the dispatcher is told when executing a redirected command to instead look on a different branch for more arguments and executes blocks. The literal argument that the redirect is placed on will also rename first literal on the targeted branch in the new command.+The redirect tells brigadier to continue parsing the command at another command node.
  
-Redirects also work in shortened aliases such as ''/mod thing <argument>'' having an alias of ''/thing <argument>'' as shown in the code below:+==== Redirects (Chainable Commands) ==== 
 +Commands such as ''/execute as @e[type=player] in the_end run tp ~ ~ ~'' are possible because of redirects. Below is an example of a chainable command:
  
-<code java> +<code java [enable_line_numbers="true"]> 
-public static void register(CommandDispatcher<ServerCommandSource> dispatcher) { +LiteralCommandNode<ServerCommandSource> root = dispatcher.register(literal("fabric_test")); 
- LiteralCommandNode node = registerShortened(dispatcher); +LiteralCommandNode<ServerCommandSource> root1 = dispatcher.register(literal("fabric_test")  
-        dispatcher.register(literal("mod") +// You can register under the same literal more than once, it will just register new parts of the branch as shown below if you register a duplicate branch an error will popup in console warning of conflicting commands but one will still work. 
-     .then(literal("thing") +    .then(literal("extra") 
-     .redirect(node))); // Option 2: /mod thing <argument> +        .then(literal("long") 
-}+            .redirect(root, this::lengthen)) // Return to root for chaining 
 +        .then(literal("short") 
 +            .redirect(root, this::shorten))) // Return to root for chaining 
 +        .then(literal("command") 
 +            .executes(ctx -> { 
 +                ctx.getSource().sendFeedback(new LiteralText("Chainable Command"), false); 
 +                return Command.SINGLE_SUCCESS; 
 +}))); 
 +</code> 
 +The redirect can also modify the CommandSource by use of a ''redirect modifier'' which can be used for builder commands.
  
-public static LiteralCommandNode registerShortened(CommandDispatcher<ServerCommandSource> dispatcher) { // Option 1: /thing <argument> +<code java [enable_line_numbers="true"]> 
-    return dispatcher.register(literal("thing") +.redirect(rootNode, context -> { 
- .then(argument("argument", word()) +    return ((ServerCommandSource) context.getSource()).withLookingAt(Vec3ArgumentType.getVec3(context, "pos")); 
-     .executes(ctx -> execute(ctx)))); +})
-}+
 </code> </code>
  
 ===== ServerCommandSource ===== ===== ServerCommandSource =====
  
-What if you wanted a command that the CommandSource must be an entity to execute? The ServerCommandSource provides this option with a couple of methods+A server command source provides some additional implementation specific context when a command is run. This includes the ability to get the entity that executed the command, the world the command was ran in or the server the command was run on.
  
-<code java> +<code java [enable_line_numbers="true"]> 
-ServerCommandSource source = ctx.getSource(); +final ServerCommandSource source = ctx.getSource(); 
 // Get the source. This will always work. // Get the source. This will always work.
  
-Entity sender = source.getEntity(); +final Entity sender = source.getEntity(); 
 // Unchecked, may be null if the sender was the console. // Unchecked, may be null if the sender was the console.
  
-Entity sender2 = source.getEntityOrThrow(); +final Entity sender2 = source.getEntityOrThrow(); 
 // Will end the command if the source of the command was not an Entity.  // Will end the command if the source of the command was not an Entity. 
 // The result of this could contain a player. Also will send feedback telling the sender of the command that they must be an entity.  // The result of this could contain a player. Also will send feedback telling the sender of the command that they must be an entity. 
Line 244: Line 267:
 // The entity options in ServerCommandSource could return a CommandBlock entity, any living entity or a player. // The entity options in ServerCommandSource could return a CommandBlock entity, any living entity or a player.
  
-ServerPlayerEntity player = source.getPlayer(); +final ServerPlayerEntity player = source.getPlayer(); 
 // Will end the command if the source of the command was not explicitly a Player. Also will send feedback telling the sender of the command that they must be a player.  This method will require your methods to throw a CommandSyntaxException // Will end the command if the source of the command was not explicitly a Player. Also will send feedback telling the sender of the command that they must be a player.  This method will require your methods to throw a CommandSyntaxException
-</code> 
  
-The ServerCommandSource also provides other information about the sender of the command. 
- 
-<code java> 
 source.getPosition();  source.getPosition(); 
 // Get's the sender's position as a Vec3 when the command was sent. This could be the location of the entity/command block or in the case of the console, the world's spawn point. // Get's the sender's position as a Vec3 when the command was sent. This could be the location of the entity/command block or in the case of the console, the world's spawn point.
Line 270: Line 289:
 </code> </code>
  
-===== Some actual examples ===== +===== A few examples =====
- +
-Just a few to show:+
  
 === Broadcast a message === === Broadcast a message ===
  
-<code java> +<code java [enable_line_numbers="true"]> 
 public static void register(CommandDispatcher<ServerCommandSource> dispatcher){ public static void register(CommandDispatcher<ServerCommandSource> dispatcher){
     dispatcher.register(literal("broadcast")     dispatcher.register(literal("broadcast")
- .requires(source -> source.hasPermissionLevel(2)) // Must be a game master to use the command. Command will not show up in tab completion or execute to non op's or any op that is permission level 1. +        .requires(source -> source.hasPermissionLevel(2)) // Must be a game master to use the command. Command will not show up in tab completion or execute to non operators or any operator that is permission level 1. 
-     .then(argument("color", ColorArgumentType.color()) +            .then(argument("color", ColorArgumentType.color()) 
- .then(argument("message", greedyString()) +                .then(argument("message", greedyString()) 
-     .executes(ctx -> broadcast(ctx.getSource(), getColor(ctx, "color"), getString(ctx, "message")))))); // You can deal with the arguments out here and pipe them into the command.+                    .executes(ctx -> broadcast(ctx.getSource(), getColor(ctx, "color"), getString(ctx, "message")))))); // You can deal with the arguments out here and pipe them into the command.
 } }
  
 public static int broadcast(ServerCommandSource source, Formatting formatting, String message) { public static int broadcast(ServerCommandSource source, Formatting formatting, String message) {
-    Text text = new LiteralText(message).formatting(formatting);+    final Text text = new LiteralText(message).formatting(formatting);
  
     source.getMinecraftServer().getPlayerManager().broadcastChatMessage(text, false);     source.getMinecraftServer().getPlayerManager().broadcastChatMessage(text, false);
Line 297: Line 314:
 First the basic code where we register "giveMeDiamond" as a literal and then an executes block to tell the dispatcher which method to run. First the basic code where we register "giveMeDiamond" as a literal and then an executes block to tell the dispatcher which method to run.
  
-<code java>+<code java [enable_line_numbers="true"]>
 public static LiteralCommandNode register(CommandDispatcher<ServerCommandSource> dispatcher) { // You can also return a LiteralCommandNode for use with possible redirects public static LiteralCommandNode register(CommandDispatcher<ServerCommandSource> dispatcher) { // You can also return a LiteralCommandNode for use with possible redirects
     return dispatcher.register(literal("giveMeDiamond")     return dispatcher.register(literal("giveMeDiamond")
Line 306: Line 323:
 Then since we only want to give to players, we check if the CommandSource is a player. But we can use ''getPlayer'' and do both at the same time and throw an error if the source is not a player. Then since we only want to give to players, we check if the CommandSource is a player. But we can use ''getPlayer'' and do both at the same time and throw an error if the source is not a player.
  
-<code java>+<code java [enable_line_numbers="true"]>
 public static int giveDiamond(CommandContext<ServerCommandSource> ctx) throws CommandSyntaxException { public static int giveDiamond(CommandContext<ServerCommandSource> ctx) throws CommandSyntaxException {
-    ServerCommandSource source = ctx.getSource();+    final ServerCommandSource source = ctx.getSource();
   
-    PlayerEntity self = source.getPlayer(); // If not a player than the command ends+    final PlayerEntity self = source.getPlayer(); // If not a player than the command ends
 </code> </code>
  
 Then we add to the player's inventory, with a check to see if the inventory is full: Then we add to the player's inventory, with a check to see if the inventory is full:
  
-<code java>+<code java [enable_line_numbers="true"]>
     if(!player.inventory.insertStack(new ItemStack(Items.DIAMOND))){     if(!player.inventory.insertStack(new ItemStack(Items.DIAMOND))){
-        throw new SimpleCommandExceptionType(new TranslateableText("inventory.isfull")).create(); +        throw new SimpleCommandExceptionType(new TranslatableText("inventory.isfull")).create(); 
-    } +    } 
     return 1;     return 1;
 } }
Line 331: Line 349:
 First create an entry into the CommandDispatcher that takes a literal of antioch with an optional argument of the location to summon the entity at. First create an entry into the CommandDispatcher that takes a literal of antioch with an optional argument of the location to summon the entity at.
  
-<code java>+<code java [enable_line_numbers="true"]>
 public static void register(CommandDispatcher<ServerCommandSource> dispatcher) { public static void register(CommandDispatcher<ServerCommandSource> dispatcher) {
     dispatcher.register(literal("antioch")     dispatcher.register(literal("antioch")
         .then(required("location", BlockPosArgumentType.blockPos()         .then(required("location", BlockPosArgumentType.blockPos()
-     .executes(ctx -> antioch(ctx.getSource(), BlockPosArgument.getBlockPos(ctx, "location"))))) +            .executes(ctx -> antioch(ctx.getSource(), BlockPosArgument.getBlockPos(ctx, "location"))))) 
- .executes(ctx -> antioch(ctx.getSource(), null)));+        .executes(ctx -> antioch(ctx.getSource(), null)));
 } }
 </code> </code>
Line 342: Line 360:
 Then the creation and messages behind the joke. Then the creation and messages behind the joke.
  
-<code java> +<code java [enable_line_numbers="true"]> 
-public static int antioch(ServerCommandSource source, BlockPos blockPos) throws CommandSyntaxException {  +public static int antioch(ServerCommandSource source, BlockPos blockPos) throws CommandSyntaxException { 
-  +    if(blockPos == null) { 
-    if(blockPos==null) { +        // For the case of no inputted argument we calculate the cursor position of the player or throw an error if the nearest position is too far or is outside of the world. 
-        blockPos = LocationUtil.calculateCursorOrThrow(source, source.getRotation()); // For the case of no inputted argument we calculate the cursor position of the player or throw an error if the nearest position is too far or is outside of the world. This class is used as an example and actually doesn't exist yet.+        // This class is used as an example and actually doesn't exist yet. 
 +        blockPos = LocationUtil.calculateCursorOrThrow(source, source.getRotation());
     }     }
-  + 
-    TntEntity tnt = new TntEntity(source.getWorld(), blockPos.getX(), blockPos.getY(), blockPos.getZ(), null);+    final TntEntity tnt = new TntEntity(source.getWorld(), blockPos.getX(), blockPos.getY(), blockPos.getZ(), null); 
 +    tnt.setFuse(3);
                  
     source.getMinecraftServer().getPlayerManager().broadcastChatMessage(new LiteralText("...lobbest thou thy Holy Hand Grenade of Antioch towards thy foe").formatting(Formatting.RED), false);     source.getMinecraftServer().getPlayerManager().broadcastChatMessage(new LiteralText("...lobbest thou thy Holy Hand Grenade of Antioch towards thy foe").formatting(Formatting.RED), false);
Line 358: Line 378:
 </code> </code>
  
-===== FAQ =====+=== Finding Biomes via Command ===
  
-=== What else can I send feedback to the CommandSource? ===+This example shows examples of redirects, exceptions, suggestions and a tiny bit of text. Note this command when used works but can take a bit of time to work similarly to ''/locate'' 
 +<code java [enable_line_numbers="true"]> 
 +public class CommandLocateBiome { 
 +    // First make method to register  
 +    public static void register(CommandDispatcher<ServerCommandSource> dispatcher) { 
 +        LiteralCommandNode<ServerCommandSource> basenode = dispatcher.register(literal("findBiome") 
 +                .then(argument("biome_identifier", identifier()).suggests(BiomeCompletionProvider.BIOMES) // We use Biome suggestions for identifier argument 
 +                        .then(argument("distance", integer(0, 20000)) 
 +                                .executes(ctx -> execute(ctx.getSource(), getIdentifier(ctx, "biome_identifier"), getInteger(ctx, "distance")))) 
 +                        .executes(ctx -> execute(ctx.getSource(), getIdentifier(ctx, "biome_identifier"), 1000)))); 
 +        // Register a redirect for /biome alias 
 +        dispatcher.register(literal("biome") 
 +                .redirect(basenode)); 
 +    }
  
-You can choose between Brigadier's default LiteralMessage or use any one of Minecraft's Text classes (LiteralText, TranslatableText)+    private static int execute(ServerCommandSource source, Identifier biomeId, int range) throws CommandSyntaxException { 
 +        Biome biome = Registry.BIOME.get(biomeId); 
 +         
 +        if(biome == null) { 
 +            // Since the argument is an Identifier we need to check if the identifier actually exists in the registry 
 +            throw new SimpleCommandExceptionType(new TranslatableText("biome.not.exist", biomeId)).create(); 
 +        } 
 +         
 +        List<Biome> bio = new ArrayList<Biome>(); 
 +        bio.add(biome);
  
-=== Why does my IDE complain saying that a method executed by my command needs to catch or throw a CommandSyntaxException ===+        ServerWorld world = source.getWorld(); 
 +        BiomeSource bsource = world.getChunkManager().getChunkGenerator().getBiomeSource(); 
 +        BlockPos loc = new BlockPos(source.getPosition());
  
-The solution to this is just to make the methods throw a CommandSyntaxException down the whole chain as the executes block handles the exceptions.+        // This call will likely block the main thread 
 +        BlockPos pos = bsource.locateBiome(loc.getX(), loc.getZ(), range, bio, new Random(world.getSeed())); 
 +         
 +        // If null, a biome was not found 
 +        if(pos == null) { 
 +            throw new SimpleCommandExceptionType(new TranslatableText("biome.notfound", biome.getTranslationKey())).create(); 
 +        }
  
-=== Can I register commands in run time? ===+        int distance = MathHelper.floor(getDistance(loc.getX(), loc.getZ(), pos.getX(), pos.getZ())); 
 +        // Popup text that can suggest commands. This is the exact same system that /locate uses. 
 +        Text teleportButtonPopup = Texts.bracketed(new TranslatableText("chat.coordinates", new Object[] { pos.getX(), "~", pos.getZ()})).styled((style) -> { 
 +            style.setColor(Formatting.GREEN).setClickEvent(new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, "/tp @s " + pos.getX() + " ~ " + pos.getZ())).setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new TranslatableText("chat.coordinates.tooltip"))); 
 +        }); 
 +         
 +        source.sendFeedback(new TranslatableText("commands.locate.success", new Object[] { new TranslatableText(Registry.BIOME.get(biomeId).getTranslationKey()), teleportButtonPopup, distance}), false);
  
-You can do this but it is not reccomended. You would get the instance of the CommandManager and add anything you wish to the CommandDispatcher within it.+        return 1; 
 +    } 
 +    // Just a normal old 2d distance method. 
 +    private static float getDistance(int int_1, int int_2, int int_3, int int_4) { 
 +        int int_5 = int_3 - int_1; 
 +        int int_6 = int_4 - int_2;
  
-After that you will need to send the command tree to every player again using ''CommandManager.sendCommandTree(PlayerEntity)''+        return MathHelper.sqrt((float) (int_5 * int_5 + int_6 * int_6)); 
 +    } 
 +     
 +    
  
-=== Can I unregister commands in run time? ===+    public static class BiomeCompletionProvider { 
 +        // This provides suggestions of what biomes can be selected. Since this uses the registry, mods that add new biomes will work without any modifications. 
 +        public static final SuggestionProvider<ServerCommandSource> BIOMES = SuggestionProviders.register(new Identifier("biomes"), (ctx, builder) -> { 
 +            Registry.BIOME.getIds().stream().forEach(identifier -> builder.suggest(identifier.toString(), new TranslatableText(Registry.BIOME.get(identifier).getTranslationKey()))); 
 +            return builder.buildFuture(); 
 +        }); 
 +         
 +    } 
 +</code>
  
-You can also do this but it is very unstable and could cause unwanted side effects. Lets just say it involves a bunch of Reflection.+===== Custom Argument Types =====
  
-Once again you will need to send the command tree to every player again using ''CommandManager.sendCommandTree(PlayerEntity)'' afterwards.+Brigadier has support for custom argument types and this section goes into showing how to create a simple argument type. 
  
-=== Can I register client side commands? ===+Warning: Custom arguments require client mod installation to be registered correctly! If you are making a server plugin, consider using existing argument type and a custom suggestions provider instead.
  
-Well Fabric currently doesn't support this natively but there is a mod by the Cotton team that adds this functionality where the commands do not run on the server and only on the client: +For this example we will create a UuidArgumentType.
-https://github.com/CottonMC/ClientCommands+
  
-If you only want the command to only be visible on the integrated server like ''/publish'' then you would modify your requires block:+First create a class which extends ''ArgumentType''. Note that ArgumentType is a generic, so the generic will define what type the ArgumentType will return
  
 +<code java [enable_line_numbers="true"]>
 +public class UuidArgumentType implements ArgumentType<UUID> {
 +</code>
 +
 +ArgumentType requires you to implement the ''parse'' method, the type it returns will match with the Generic type.
 <code java> <code java>
-dispatcher.register(literal("publish") +@Override 
-    // The permission level 4 on integrated server is the equivalent of having cheats enabled. +public UUID parse(StringReader reader) throws CommandSyntaxException {
-    .requires(source -> source.getMinecraftServer().isSinglePlayer() && source.hasPermissionLevel(4)));+
 </code> </code>
  
-=== I want to access X from my mod when a command is ran ===+This method is where all of your parsing will occur. Either this method will return the object based on the arguments provided in the command line or throw a CommandSyntaxException and parsing will fail.
  
-This is going to require a way to statically access your mod with a ''getInstance'' call. Below is a very simple instance system you can place in your mod+Next you will store the current position of the cursor, this is so you can substring out only the specific argument. This will always be at the beginning of where your argument appears on the command line.
  
-<code java> +<code java [enable_line_numbers="true"]> 
-private static Type instance; +int argBeginning = reader.getCursor(); // The starting position of the cursor is at the beginning of the argument. 
- +if (!reader.canRead()) { 
-static { // Static option on class initalize for seperate API class for example +    reader.skip();
-   instance = new Type();+
 } }
 +</code>
  
-public void onInitalize() { // If within your mod initalizer +Now we grab the entire argument. Depending on your argument type, you may have a different criteria or be similar to some arguments where detecting a ''{'' on the command line will require it to be closed. For a UUID we will just figure out what cursor position the argument ends at. 
-   instance = this;+ 
 +<code java [enable_line_numbers="true"]> 
 +while (reader.canRead() && reader.peek() != ' ') { // peek provides the character at the current cursor position. 
 +    reader.skip(); // Tells the StringReader to move it's cursor to the next position.
 } }
 +</code>
  
-public static Type getInstance() { +Then we will ask the StringReader what the current position of the cursor is an substring our argument out of the command line. 
-    return instance;+ 
 +<code java [enable_line_numbers="true"]>String uuidString = reader.getString().substring(argBeginning, reader.getCursor());</code> 
 + 
 +Now finally we check if our argument is correct and parse the specific argument to our liking, and throwing an exception if the parsing fails. 
 + 
 +<code java [enable_line_numbers="true"]> 
 +try { 
 +    UUID uuid = UUID.fromString(uuidString); // Now our actual logic. 
 +    return uuid; // And we return our type, in this case the parser will consider this argument to have parsed properly and then move on. 
 +    } catch (Exception ex) { 
 +    // UUIDs can throw an exception when made by a string, so we catch the exception and repackage it into a CommandSyntaxException type. 
 +    // Create with context tells Brigadier to supply some context to tell the user where the command failed at. 
 +    // Though normal create method could be used. 
 +    throw new SimpleCommandExceptionType(new LiteralText(ex.getMessage())).createWithContext(reader);
 } }
 </code> </code>
 +
 +The ArgumentType is done, however your client will refuse the parse the argument and throw an error. This is because the server will tell the client what argument type the command node is. And the client will not parse any argument types it does not know how to parse. To fix this we need to register an ArgumentSerializer. 
 +Within your ModInitializer. For more complex argument types, you may need to create your own ArgumentSerializer.
 +
 +<code java [enable_line_numbers="true"]>
 +ArgumentTypes.register("mymod:uuid", UuidArgumentType.class, new ConstantArgumentSerializer(UuidArgumentType::uuid)); 
 +// The argument should be what will create the ArgumentType.
 +</code>
 +
 +And here is the whole ArgumentType:
 +
 +<file java UuidArgumentType.java [enable_line_numbers="true"]>
 +
 +import com.mojang.brigadier.StringReader;
 +import com.mojang.brigadier.arguments.ArgumentType;
 +import com.mojang.brigadier.context.CommandContext;
 +import com.mojang.brigadier.exceptions.CommandSyntaxException;
 +import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
 +import net.minecraft.text.LiteralText;
 +import net.minecraft.util.SystemUtil;
 +
 +import java.util.ArrayList;
 +import java.util.Collection;
 +import java.util.UUID;
 +
 +/**
 + * Represents an ArgumentType that will return a UUID.
 + */
 +public class UuidArgumentType implements ArgumentType<UUID> {
 +    public static UuidArgumentType uuid() {
 +        return new UuidArgumentType();
 +    }
 +
 +    public static <S> UUID getUuid(String name, CommandContext<S> context) {
 +        // Note that you should assume the CommandSource wrapped inside of the CommandContext will always be a generic type.
 +        // If you need to access the ServerCommandSource make sure you verify the source is a server command source before casting.
 +        return context.getArgument(name, UUID.class);
 +    }
 +
 +    private static final Collection<String> EXAMPLES = SystemUtil.consume(new ArrayList<>(), list -> {
 +        list.add("765e5d33-c991-454f-8775-b6a7a394c097"); // i509VCB: Username The_1_gamers
 +        list.add("069a79f4-44e9-4726-a5be-fca90e38aaf5"); // Notch
 +        list.add("61699b2e-d327-4a01-9f1e-0ea8c3f06bc6"); // Dinnerbone
 +    });
 +
 +    @Override
 +    public UUID parse(StringReader reader) throws CommandSyntaxException {
 +        int argBeginning = reader.getCursor(); // The starting position of the cursor is at the beginning of the argument.
 +        if (!reader.canRead()) {
 +            reader.skip();
 +        }
 +
 +        // Now we check the contents of the argument till either we hit the end of the command line (When canRead becomes false)
 +        // Otherwise we go till reach reach a space, which signifies the next argument
 +        while (reader.canRead() && reader.peek() != ' ') { // peek provides the character at the current cursor position.
 +            reader.skip(); // Tells the StringReader to move it's cursor to the next position.
 +        }
 +
 +        // Now we substring the specific part we want to see using the starting cursor position and the ends where the next argument starts.
 +        String uuidString = reader.getString().substring(argBeginning, reader.getCursor());
 +        try {
 +            UUID uuid = UUID.fromString(uuidString); // Now our actual logic.
 +            return uuid; // And we return our type, in this case the parser will consider this argument to have parsed properly and then move on.
 +        } catch (Exception ex) {
 +            // UUIDs can throw an exception when made by a string, so we catch the exception and repackage it into a CommandSyntaxException type.
 +            // Create with context tells Brigadier to supply some context to tell the user where the command failed at.
 +            // Though normal create method could be used.
 +            throw new SimpleCommandExceptionType(new LiteralText(ex.getMessage())).createWithContext(reader);
 +        }
 +    }
 +
 +    @Override
 +    public Collection<String> getExamples() { // Brigadier has support to show examples for what the argument should look like, this should contain a Collection of only the argument this type will return. This is mainly used to calculate ambiguous commands which share the exact same 
 +        return EXAMPLES;
 +    }
 +}
 +</file>
 +===== FAQ =====
 +
 +=== What else can I send feedback to the CommandSource? ===
 +
 +You use the Text classes (LiteralText, TranslatableText, KeybindText, etc).
 +
 +=== Why does my IDE complain saying that a method executed by my command needs to catch or throw a CommandSyntaxException ===
 +
 +The solution to this is just to make the methods throw a CommandSyntaxException down the whole chain as the executes block handles the exceptions.
 +
 +=== Can I register commands runtime? ===
 +
 +You can do this but it is not reccomended. You would get the instance of the CommandManager and add anything you wish to the CommandDispatcher within it.
 +
 +After that you will need to send the command tree to every player again using ''CommandManager.sendCommandTree(ServerPlayerEntity)''
 +
 +=== Can I unregister commands runtime? ===
 +
 +You can also do this but it is very unstable and could cause unwanted side effects. Lets just say it involves a bunch of Reflection.
 +
 +Once again you will need to send the command tree to every player again using ''CommandManager.sendCommandTree(ServerPlayerEntity)'' afterwards.
 +
 +=== Can I register client side commands? ===
 +
 +Well Fabric currently doesn't support this natively but there is a mod by the Cotton team that adds this functionality where the commands do not run on the server and only on the client:
 +https://github.com/CottonMC/ClientCommands
tutorial/commands.txt · Last modified: 2024/02/23 14:22 by allen1210