======= Command Redirects =======

Redirects are Brigadier's form of aliases and subcommands. The ''redirect'' method takes a command node and an optional modifier of context. The command node can be a specific node after a registration of dispathcer, or just the root node.

===== Aliases =====
In vanilla Minecraft, ''/tell'' and ''/w'' are redirected to ''/msg'', which you can see in ''MessageCommand''.

The example shows how ''/foo2'' redirects to ''/foo''.

<code java [enable_line_numbers="true"]>
public class ExampleMod implements ModInitializer {
  @Override
  public void onInitialize() {
    CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
      final LiteralCommandNode<ServerCommandSource> fooNode = dispatcher.register(literal("foo")
          .executes(context -> {
            context.getSource().sendFeedback(() -> Text.literal("Called /foo with no arguments"), true);

            return 1;
          }));
      dispatcher.register(literal("foo2").redirect(fooNode));
    });
  }
}
</code>

The ''redirect'' tells brigadier to continue parsing the command at another command node. That's to say, what's after the "foo2" node is right what's after the "foo" node.

The redirection target may not always be the root node. Commans can be redirected to sub-nodes, including arguments.

===== Chainable Commands ======
Commands such as ''/execute as @e[type=player] in the_end run tp ~ ~ ~'' are also possible because of redirects.

Let's first consider the vanilla ''/execute'' command. There is a node after the ''%%literal("execute")%%''. After dispatching subcommands, the dispatcher is redirected to that node (with some modifiers), making you possible to, after completing sub-command arguments, type whatever can be typed directly after ''/execute''. In the sub-command ''run'', the dispatcher is redirected to the root node (''dispatcher.getRoot()''), allowing you to type another complete command after the word "''run''".

Below is an example of a chainable command:

<code java [enable_line_numbers="true"]>
LiteralCommandNode<ServerCommandSource> rootNode = dispatcher.register(literal("fabric_test"));
LiteralCommandNode<ServerCommandSource> root1 = dispatcher.register(literal("fabric_test") 
    // 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("extra")
        .then(literal("long")
            .redirect(rootNode, this::lengthen)) // Return to root for chaining
        .then(literal("short")
            .redirect(rootNode, this::shorten))) // Return to root for chaining
        .then(literal("command")
            .executes(ctx -> {
                ctx.getSource().sendFeedback(() -> Text.literal("Chainable Command"), true);
                return Command.SINGLE_SUCCESS;
            })));
</code>

The ''redirect'' can also modify the ''CommandSource'' by use of a "redirect modifier" (''SingleRedirectModifier<S>''), which is usually used as a lambda.

<code java [enable_line_numbers="true"]>
            .redirect(rootNode, context -> {
                // When redirecting, modify the looking direction of the command source.
                return context.getSource().withLookingAt(Vec3ArgumentType.getVec3(context, "pos"));
            })
</code>

:!: In the redirect modifier, only arguments after the redirected nodes can be used. Meanwhile, arguments before the redirect modifier cannot be used in subsequent redirections (if any) or the final execution.