Commands.java

net.minecraft.commands.Commands

信息

• 全限定名：net.minecraft.commands.Commands
• 类型：public class
• 包：net.minecraft.commands
• 源码路径：src/main/java/net/minecraft/commands/Commands.java
• 起始行号：L159
• 职责：

  TODO

字段/常量

• COMMAND_PREFIX

  • 类型: String
  • 修饰符: public static final
  • 源码定位: L160
  • 说明:

    TODO

• CURRENT_EXECUTION_CONTEXT

  • 类型: ThreadLocal<ExecutionContext<CommandSourceStack>>
  • 修饰符: private static final
  • 源码定位: L161
  • 说明:

    TODO

• LOGGER

  • 类型: Logger
  • 修饰符: private static final
  • 源码定位: L162
  • 说明:

    TODO

• LEVEL_ALL

  • 类型: PermissionCheck
  • 修饰符: public static final
  • 源码定位: L163
  • 说明:

    TODO

• LEVEL_MODERATORS

  • 类型: PermissionCheck
  • 修饰符: public static final
  • 源码定位: L164
  • 说明:

    TODO

• LEVEL_GAMEMASTERS

  • 类型: PermissionCheck
  • 修饰符: public static final
  • 源码定位: L165
  • 说明:

    TODO

• LEVEL_ADMINS

  • 类型: PermissionCheck
  • 修饰符: public static final
  • 源码定位: L166
  • 说明:

    TODO

• LEVEL_OWNERS

  • 类型: PermissionCheck
  • 修饰符: public static final
  • 源码定位: L167
  • 说明:

    TODO

• COMMAND_NODE_INSPECTOR

  • 类型: ClientboundCommandsPacket.NodeInspector<CommandSourceStack>
  • 修饰符: private static final private final public public public
  • 源码定位: L168
  • 说明:

    TODO

• dispatcher

  • 类型: CommandDispatcher<CommandSourceStack>
  • 修饰符: private final
  • 源码定位: L188
  • 说明:

    TODO

内部类/嵌套类型

• net.minecraft.commands.Commands.CommandSelection

  • 类型: enum
  • 修饰符: public static
  • 源码定位: L552
  • 说明:

    TODO

• net.minecraft.commands.Commands.ParseFunction

  • 类型: interface
  • 修饰符: public
  • 源码定位: L567
  • 说明:

    TODO

构造器

public Commands(Commands.CommandSelection commandSelection, CommandBuildContext context) @ L190

• 构造器名：Commands
• 源码定位：L190
• 修饰符：public

参数:

• commandSelection: Commands.CommandSelection
• context: CommandBuildContext

说明:

TODO

方法

下面的方法块按源码顺序生成。

public static <S> ParseResults<S> mapSource(ParseResults<S> parse, UnaryOperator<S> sourceOperator) @ L305

• 方法名：mapSource
• 源码定位：L305
• 返回类型： ParseResults
• 修饰符：public static

参数:

• parse: ParseResults
• sourceOperator: UnaryOperator

说明:

TODO

public void performPrefixedCommand(CommandSourceStack sender, String command) @ L311

• 方法名：performPrefixedCommand
• 源码定位：L311
• 返回类型：void
• 修饰符：public

参数:

• sender: CommandSourceStack
• command: String

说明:

TODO

public static String trimOptionalPrefix(String command) @ L316

• 方法名：trimOptionalPrefix
• 源码定位：L316
• 返回类型：String
• 修饰符：public static

参数:

• command: String

说明:

TODO

public void performCommand(ParseResults<CommandSourceStack> command, String commandString) @ L320

• 方法名：performCommand
• 源码定位：L320
• 返回类型：void
• 修饰符：public

参数:

• command: ParseResults
• commandString: String

说明:

TODO

private static ContextChain<CommandSourceStack> finishParsing(ParseResults<CommandSourceStack> command, String commandString, CommandSourceStack sender) @ L360

• 方法名：finishParsing
• 源码定位：L360
• 返回类型：ContextChain
• 修饰符：private static

参数:

• command: ParseResults
• commandString: String
• sender: CommandSourceStack

说明:

TODO

public static void executeCommandInContext(CommandSourceStack context, Consumer<ExecutionContext<CommandSourceStack>> config) @ L392

• 方法名：executeCommandInContext
• 源码定位：L392
• 返回类型：void
• 修饰符：public static

参数:

• context: CommandSourceStack
• config: Consumer<ExecutionContext>

说明:

TODO

public void sendCommands(ServerPlayer player) @ L412

• 方法名：sendCommands
• 源码定位：L412
• 返回类型：void
• 修饰符：public

参数:

• player: ServerPlayer

说明:

TODO

private static <S> void fillUsableCommands(CommandNode<S> source, CommandNode<S> target, S commandFilter, Map<CommandNode<S>,CommandNode<S>> converted) @ L420

• 方法名：fillUsableCommands
• 源码定位：L420
• 返回类型： void
• 修饰符：private static

参数:

• source: CommandNode
• target: CommandNode
• commandFilter: S
• converted: Map<CommandNode,CommandNode>

说明:

TODO

public static LiteralArgumentBuilder<CommandSourceStack> literal(String literal) @ L438

• 方法名：literal
• 源码定位：L438
• 返回类型：LiteralArgumentBuilder
• 修饰符：public static

参数:

• literal: String

说明:

TODO

public static <T> RequiredArgumentBuilder<CommandSourceStack,T> argument(String name, ArgumentType<T> type) @ L442

• 方法名：argument
• 源码定位：L442
• 返回类型： RequiredArgumentBuilder<CommandSourceStack,T>
• 修饰符：public static

参数:

• name: String
• type: ArgumentType

说明:

TODO

public static Predicate<String> createValidator(Commands.ParseFunction parser) @ L446

• 方法名：createValidator
• 源码定位：L446
• 返回类型：Predicate
• 修饰符：public static

参数:

• parser: Commands.ParseFunction

说明:

TODO

public CommandDispatcher<CommandSourceStack> getDispatcher() @ L457

• 方法名：getDispatcher
• 源码定位：L457
• 返回类型：CommandDispatcher
• 修饰符：public

参数:

• 无

说明:

TODO

public static <S> void validateParseResults(ParseResults<S> command) @ L461

• 方法名：validateParseResults
• 源码定位：L461
• 返回类型： void
• 修饰符：public static

参数:

• command: ParseResults

说明:

TODO

public static <S> CommandSyntaxException getParseException(ParseResults<S> parse) @ L468

• 方法名：getParseException
• 源码定位：L468
• 返回类型： CommandSyntaxException
• 修饰符：public static

参数:

• parse: ParseResults

说明:

TODO

public static CommandBuildContext createValidationContext(HolderLookup.Provider registries) @ L480

• 方法名：createValidationContext
• 源码定位：L480
• 返回类型：CommandBuildContext
• 修饰符：public static

参数:

• registries: HolderLookup.Provider

说明:

TODO

public static void validate() @ L523

• 方法名：validate
• 源码定位：L523
• 返回类型：void
• 修饰符：public static

参数:

• 无

说明:

TODO

public static <T extends PermissionSetSupplier> PermissionProviderCheck<T> hasPermission(PermissionCheck permission) @ L544

• 方法名：hasPermission
• 源码定位：L544
• 返回类型： PermissionProviderCheck
• 修饰符：public static

参数:

• permission: PermissionCheck

说明:

TODO

public static CommandSourceStack createCompilationContext(PermissionSet compilationPermissions) @ L548

• 方法名：createCompilationContext
• 源码定位：L548
• 返回类型：CommandSourceStack
• 修饰符：public static

参数:

• compilationPermissions: PermissionSet

说明:

TODO

代码

public class Commands {
    public static final String COMMAND_PREFIX = "/";
    private static final ThreadLocal<@Nullable ExecutionContext<CommandSourceStack>> CURRENT_EXECUTION_CONTEXT = new ThreadLocal<>();
    private static final Logger LOGGER = LogUtils.getLogger();
    public static final PermissionCheck LEVEL_ALL = PermissionCheck.AlwaysPass.INSTANCE;
    public static final PermissionCheck LEVEL_MODERATORS = new PermissionCheck.Require(Permissions.COMMANDS_MODERATOR);
    public static final PermissionCheck LEVEL_GAMEMASTERS = new PermissionCheck.Require(Permissions.COMMANDS_GAMEMASTER);
    public static final PermissionCheck LEVEL_ADMINS = new PermissionCheck.Require(Permissions.COMMANDS_ADMIN);
    public static final PermissionCheck LEVEL_OWNERS = new PermissionCheck.Require(Permissions.COMMANDS_OWNER);
    private static final ClientboundCommandsPacket.NodeInspector<CommandSourceStack> COMMAND_NODE_INSPECTOR = new ClientboundCommandsPacket.NodeInspector<CommandSourceStack>() {
        private final CommandSourceStack noPermissionSource = Commands.createCompilationContext(PermissionSet.NO_PERMISSIONS);
 
        @Override
        public @Nullable Identifier suggestionId(ArgumentCommandNode<CommandSourceStack, ?> node) {
            SuggestionProvider<CommandSourceStack> suggestionProvider = node.getCustomSuggestions();
            return suggestionProvider != null ? SuggestionProviders.getName(suggestionProvider) : null;
        }
 
        @Override
        public boolean isExecutable(CommandNode<CommandSourceStack> node) {
            return node.getCommand() != null;
        }
 
        @Override
        public boolean isRestricted(CommandNode<CommandSourceStack> node) {
            Predicate<CommandSourceStack> requirement = node.getRequirement();
            return !requirement.test(this.noPermissionSource);
        }
    };
    private final CommandDispatcher<CommandSourceStack> dispatcher = new CommandDispatcher<>();
 
    public Commands(Commands.CommandSelection commandSelection, CommandBuildContext context) {
        AdvancementCommands.register(this.dispatcher);
        AttributeCommand.register(this.dispatcher, context);
        ExecuteCommand.register(this.dispatcher, context);
        BossBarCommands.register(this.dispatcher, context);
        ClearInventoryCommands.register(this.dispatcher, context);
        CloneCommands.register(this.dispatcher, context);
        DamageCommand.register(this.dispatcher, context);
        DataCommands.register(this.dispatcher);
        DataPackCommand.register(this.dispatcher, context);
        DebugCommand.register(this.dispatcher);
        DefaultGameModeCommands.register(this.dispatcher);
        DialogCommand.register(this.dispatcher, context);
        DifficultyCommand.register(this.dispatcher);
        EffectCommands.register(this.dispatcher, context);
        EmoteCommands.register(this.dispatcher);
        EnchantCommand.register(this.dispatcher, context);
        ExperienceCommand.register(this.dispatcher);
        FillCommand.register(this.dispatcher, context);
        FillBiomeCommand.register(this.dispatcher, context);
        ForceLoadCommand.register(this.dispatcher);
        FunctionCommand.register(this.dispatcher);
        GameModeCommand.register(this.dispatcher);
        GameRuleCommand.register(this.dispatcher, context);
        GiveCommand.register(this.dispatcher, context);
        HelpCommand.register(this.dispatcher);
        ItemCommands.register(this.dispatcher, context);
        KickCommand.register(this.dispatcher);
        KillCommand.register(this.dispatcher);
        ListPlayersCommand.register(this.dispatcher);
        LocateCommand.register(this.dispatcher, context);
        LootCommand.register(this.dispatcher, context);
        MsgCommand.register(this.dispatcher);
        SwingCommand.register(this.dispatcher);
        ParticleCommand.register(this.dispatcher, context);
        PlaceCommand.register(this.dispatcher);
        PlaySoundCommand.register(this.dispatcher);
        RandomCommand.register(this.dispatcher);
        ReloadCommand.register(this.dispatcher);
        RecipeCommand.register(this.dispatcher);
        FetchProfileCommand.register(this.dispatcher);
        ReturnCommand.register(this.dispatcher);
        RideCommand.register(this.dispatcher);
        RotateCommand.register(this.dispatcher);
        SayCommand.register(this.dispatcher);
        ScheduleCommand.register(this.dispatcher);
        ScoreboardCommand.register(this.dispatcher, context);
        SeedCommand.register(this.dispatcher, commandSelection != Commands.CommandSelection.INTEGRATED);
        VersionCommand.register(this.dispatcher, commandSelection != Commands.CommandSelection.INTEGRATED);
        SetBlockCommand.register(this.dispatcher, context);
        SetSpawnCommand.register(this.dispatcher);
        SetWorldSpawnCommand.register(this.dispatcher);
        SpectateCommand.register(this.dispatcher);
        SpreadPlayersCommand.register(this.dispatcher);
        StopSoundCommand.register(this.dispatcher);
        StopwatchCommand.register(this.dispatcher);
        SummonCommand.register(this.dispatcher, context);
        TagCommand.register(this.dispatcher);
        TeamCommand.register(this.dispatcher, context);
        TeamMsgCommand.register(this.dispatcher);
        TeleportCommand.register(this.dispatcher);
        TellRawCommand.register(this.dispatcher, context);
        TestCommand.register(this.dispatcher, context);
        TickCommand.register(this.dispatcher);
        TimeCommand.register(this.dispatcher, context);
        TitleCommand.register(this.dispatcher, context);
        TriggerCommand.register(this.dispatcher);
        WaypointCommand.register(this.dispatcher, context);
        WeatherCommand.register(this.dispatcher);
        WorldBorderCommand.register(this.dispatcher);
        if (JvmProfiler.INSTANCE.isAvailable()) {
            JfrCommand.register(this.dispatcher);
        }
 
        if (SharedConstants.DEBUG_CHASE_COMMAND) {
            ChaseCommand.register(this.dispatcher);
        }
 
        if (SharedConstants.DEBUG_DEV_COMMANDS || SharedConstants.IS_RUNNING_IN_IDE) {
            RaidCommand.register(this.dispatcher, context);
            DebugPathCommand.register(this.dispatcher);
            DebugMobSpawningCommand.register(this.dispatcher);
            WardenSpawnTrackerCommand.register(this.dispatcher);
            SpawnArmorTrimsCommand.register(this.dispatcher);
            ServerPackCommand.register(this.dispatcher);
            if (commandSelection.includeDedicated) {
                DebugConfigCommand.register(this.dispatcher, context);
            }
        }
 
        if (commandSelection.includeDedicated) {
            BanIpCommands.register(this.dispatcher);
            BanListCommands.register(this.dispatcher);
            BanPlayerCommands.register(this.dispatcher);
            DeOpCommands.register(this.dispatcher);
            OpCommand.register(this.dispatcher);
            PardonCommand.register(this.dispatcher);
            PardonIpCommand.register(this.dispatcher);
            PerfCommand.register(this.dispatcher);
            SaveAllCommand.register(this.dispatcher);
            SaveOffCommand.register(this.dispatcher);
            SaveOnCommand.register(this.dispatcher);
            SetPlayerIdleTimeoutCommand.register(this.dispatcher);
            StopCommand.register(this.dispatcher);
            TransferCommand.register(this.dispatcher);
            WhitelistCommand.register(this.dispatcher);
        }
 
        if (commandSelection.includeIntegrated) {
            PublishCommand.register(this.dispatcher);
        }
 
        this.dispatcher.setConsumer(ExecutionCommandSource.resultConsumer());
    }
 
    public static <S> ParseResults<S> mapSource(ParseResults<S> parse, UnaryOperator<S> sourceOperator) {
        CommandContextBuilder<S> context = parse.getContext();
        CommandContextBuilder<S> source = context.withSource(sourceOperator.apply(context.getSource()));
        return new ParseResults<>(source, parse.getReader(), parse.getExceptions());
    }
 
    public void performPrefixedCommand(CommandSourceStack sender, String command) {
        command = trimOptionalPrefix(command);
        this.performCommand(this.dispatcher.parse(command, sender), command);
    }
 
    public static String trimOptionalPrefix(String command) {
        return command.startsWith("/") ? command.substring(1) : command;
    }
 
    public void performCommand(ParseResults<CommandSourceStack> command, String commandString) {
        CommandSourceStack sender = command.getContext().getSource();
        Profiler.get().push(() -> "/" + commandString);
        ContextChain<CommandSourceStack> commandChain = finishParsing(command, commandString, sender);
 
        try {
            if (commandChain != null) {
                executeCommandInContext(
                    sender,
                    executionContext -> ExecutionContext.queueInitialCommandExecution(
                        executionContext, commandString, commandChain, sender, CommandResultCallback.EMPTY
                    )
                );
            }
        } catch (Exception var12) {
            MutableComponent hover = Component.literal(var12.getMessage() == null ? var12.getClass().getName() : var12.getMessage());
            if (LOGGER.isDebugEnabled()) {
                LOGGER.error("Command exception: /{}", commandString, var12);
                StackTraceElement[] stackTrace = var12.getStackTrace();
 
                for (int i = 0; i < Math.min(stackTrace.length, 3); i++) {
                    hover.append("\n\n")
                        .append(stackTrace[i].getMethodName())
                        .append("\n ")
                        .append(stackTrace[i].getFileName())
                        .append(":")
                        .append(String.valueOf(stackTrace[i].getLineNumber()));
                }
            }
 
            sender.sendFailure(Component.translatable("command.failed").withStyle(s -> s.withHoverEvent(new HoverEvent.ShowText(hover))));
            if (SharedConstants.DEBUG_VERBOSE_COMMAND_ERRORS || SharedConstants.IS_RUNNING_IN_IDE) {
                sender.sendFailure(Component.literal(Util.describeError(var12)));
                LOGGER.error("'/{}' threw an exception", commandString, var12);
            }
        } finally {
            Profiler.get().pop();
        }
    }
 
    private static @Nullable ContextChain<CommandSourceStack> finishParsing(
        ParseResults<CommandSourceStack> command, String commandString, CommandSourceStack sender
    ) {
        try {
            validateParseResults(command);
            return ContextChain.tryFlatten(command.getContext().build(commandString))
                .orElseThrow(() -> CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand().createWithContext(command.getReader()));
        } catch (CommandSyntaxException var7) {
            sender.sendFailure(ComponentUtils.fromMessage(var7.getRawMessage()));
            if (var7.getInput() != null && var7.getCursor() >= 0) {
                int cursor = Math.min(var7.getInput().length(), var7.getCursor());
                MutableComponent context = Component.empty()
                    .withStyle(ChatFormatting.GRAY)
                    .withStyle(s -> s.withClickEvent(new ClickEvent.SuggestCommand("/" + commandString)));
                if (cursor > 10) {
                    context.append(CommonComponents.ELLIPSIS);
                }
 
                context.append(var7.getInput().substring(Math.max(0, cursor - 10), cursor));
                if (cursor < var7.getInput().length()) {
                    Component remaining = Component.literal(var7.getInput().substring(cursor)).withStyle(ChatFormatting.RED, ChatFormatting.UNDERLINE);
                    context.append(remaining);
                }
 
                context.append(Component.translatable("command.context.here").withStyle(ChatFormatting.RED, ChatFormatting.ITALIC));
                sender.sendFailure(context);
            }
 
            return null;
        }
    }
 
    public static void executeCommandInContext(CommandSourceStack context, Consumer<ExecutionContext<CommandSourceStack>> config) {
        ExecutionContext<CommandSourceStack> currentContext = CURRENT_EXECUTION_CONTEXT.get();
        boolean isTopContext = currentContext == null;
        if (isTopContext) {
            GameRules gameRules = context.getLevel().getGameRules();
            int chainLimit = Math.max(1, gameRules.get(GameRules.MAX_COMMAND_SEQUENCE_LENGTH));
            int forkLimit = gameRules.get(GameRules.MAX_COMMAND_FORKS);
 
            try (ExecutionContext<CommandSourceStack> executionContext = new ExecutionContext<>(chainLimit, forkLimit, Profiler.get())) {
                CURRENT_EXECUTION_CONTEXT.set(executionContext);
                config.accept(executionContext);
                executionContext.runCommandQueue();
            } finally {
                CURRENT_EXECUTION_CONTEXT.set(null);
            }
        } else {
            config.accept(currentContext);
        }
    }
 
    public void sendCommands(ServerPlayer player) {
        Map<CommandNode<CommandSourceStack>, CommandNode<CommandSourceStack>> playerCommands = new HashMap<>();
        RootCommandNode<CommandSourceStack> root = new RootCommandNode<>();
        playerCommands.put(this.dispatcher.getRoot(), root);
        fillUsableCommands(this.dispatcher.getRoot(), root, player.createCommandSourceStack(), playerCommands);
        player.connection.send(new ClientboundCommandsPacket(root, COMMAND_NODE_INSPECTOR));
    }
 
    private static <S> void fillUsableCommands(CommandNode<S> source, CommandNode<S> target, S commandFilter, Map<CommandNode<S>, CommandNode<S>> converted) {
        for (CommandNode<S> child : source.getChildren()) {
            if (child.canUse(commandFilter)) {
                ArgumentBuilder<S, ?> builder = child.createBuilder();
                if (builder.getRedirect() != null) {
                    builder.redirect(converted.get(builder.getRedirect()));
                }
 
                CommandNode<S> node = builder.build();
                converted.put(child, node);
                target.addChild(node);
                if (!child.getChildren().isEmpty()) {
                    fillUsableCommands(child, node, commandFilter, converted);
                }
            }
        }
    }
 
    public static LiteralArgumentBuilder<CommandSourceStack> literal(String literal) {
        return LiteralArgumentBuilder.literal(literal);
    }
 
    public static <T> RequiredArgumentBuilder<CommandSourceStack, T> argument(String name, ArgumentType<T> type) {
        return RequiredArgumentBuilder.argument(name, type);
    }
 
    public static Predicate<String> createValidator(Commands.ParseFunction parser) {
        return value -> {
            try {
                parser.parse(new StringReader(value));
                return true;
            } catch (CommandSyntaxException var3) {
                return false;
            }
        };
    }
 
    public CommandDispatcher<CommandSourceStack> getDispatcher() {
        return this.dispatcher;
    }
 
    public static <S> void validateParseResults(ParseResults<S> command) throws CommandSyntaxException {
        CommandSyntaxException parseException = getParseException(command);
        if (parseException != null) {
            throw parseException;
        }
    }
 
    public static <S> @Nullable CommandSyntaxException getParseException(ParseResults<S> parse) {
        if (!parse.getReader().canRead()) {
            return null;
        } else if (parse.getExceptions().size() == 1) {
            return parse.getExceptions().values().iterator().next();
        } else {
            return parse.getContext().getRange().isEmpty()
                ? CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand().createWithContext(parse.getReader())
                : CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownArgument().createWithContext(parse.getReader());
        }
    }
 
    public static CommandBuildContext createValidationContext(HolderLookup.Provider registries) {
        return new CommandBuildContext() {
            @Override
            public FeatureFlagSet enabledFeatures() {
                return FeatureFlags.REGISTRY.allFlags();
            }
 
            @Override
            public Stream<ResourceKey<? extends Registry<?>>> listRegistryKeys() {
                return registries.listRegistryKeys();
            }
 
            @Override
            public <T> Optional<HolderLookup.RegistryLookup<T>> lookup(ResourceKey<? extends Registry<? extends T>> key) {
                return registries.lookup(key).map(this::createLookup);
            }
 
            private <T> HolderLookup.RegistryLookup.Delegate<T> createLookup(HolderLookup.RegistryLookup<T> original) {
                return new HolderLookup.RegistryLookup.Delegate<T>() {
                    {
                        
                    }
 
                    @Override
                    public HolderLookup.RegistryLookup<T> parent() {
                        return original;
                    }
 
                    @Override
                    public Optional<HolderSet.Named<T>> get(TagKey<T> id) {
                        return Optional.of(this.getOrThrow(id));
                    }
 
                    @Override
                    public HolderSet.Named<T> getOrThrow(TagKey<T> id) {
                        Optional<HolderSet.Named<T>> tag = this.parent().get(id);
                        return tag.orElseGet(() -> HolderSet.emptyNamed(this.parent(), id));
                    }
                };
            }
        };
    }
 
    public static void validate() {
        CommandBuildContext context = createValidationContext(VanillaRegistries.createLookup());
        CommandDispatcher<CommandSourceStack> dispatcher = new Commands(Commands.CommandSelection.ALL, context).getDispatcher();
        RootCommandNode<CommandSourceStack> root = dispatcher.getRoot();
        dispatcher.findAmbiguities(
            (parent, child, sibling, ambiguities) -> LOGGER.warn(
                "Ambiguity between arguments {} and {} with inputs: {}", dispatcher.getPath(child), dispatcher.getPath(sibling), ambiguities
            )
        );
        Set<ArgumentType<?>> usedArgumentTypes = ArgumentUtils.findUsedArgumentTypes(root);
        Set<ArgumentType<?>> unregisteredTypes = usedArgumentTypes.stream()
            .filter(arg -> !ArgumentTypeInfos.isClassRecognized(arg.getClass()))
            .collect(Collectors.toSet());
        if (!unregisteredTypes.isEmpty()) {
            LOGGER.warn(
                "Missing type registration for following arguments:\n {}", unregisteredTypes.stream().map(arg -> "\t" + arg).collect(Collectors.joining(",\n"))
            );
            throw new IllegalStateException("Unregistered argument types");
        }
    }
 
    public static <T extends PermissionSetSupplier> PermissionProviderCheck<T> hasPermission(PermissionCheck permission) {
        return new PermissionProviderCheck<>(permission);
    }
 
    public static CommandSourceStack createCompilationContext(PermissionSet compilationPermissions) {
        return new CommandSourceStack(CommandSource.NULL, Vec3.ZERO, Vec2.ZERO, null, compilationPermissions, "", CommonComponents.EMPTY, null, null);
    }
 
    public static enum CommandSelection {
        ALL(true, true),
        DEDICATED(false, true),
        INTEGRATED(true, false);
 
        private final boolean includeIntegrated;
        private final boolean includeDedicated;
 
        private CommandSelection(boolean includeIntegrated, boolean includeDedicated) {
            this.includeIntegrated = includeIntegrated;
            this.includeDedicated = includeDedicated;
        }
    }
 
    @FunctionalInterface
    public interface ParseFunction {
        void parse(StringReader value) throws CommandSyntaxException;
    }
}

引用的其他类

• CommandBuildContext

  • 引用位置: 参数/构造调用/返回值
  • 关联成员: CommandBuildContext()

• CommandSourceStack

  • 引用位置: 参数/字段/构造调用/返回值
  • 关联成员: CommandSourceStack()

• ExecutionCommandSource

  • 引用位置: 方法调用
  • 关联成员: ExecutionCommandSource.resultConsumer()

• ExecutionContext

  • 引用位置: 参数/字段/方法调用
  • 关联成员: ExecutionContext.queueInitialCommandExecution()

• ArgumentTypeInfos

  • 引用位置: 方法调用
  • 关联成员: ArgumentTypeInfos.isClassRecognized()

• ArgumentUtils

  • 引用位置: 方法调用
  • 关联成员: ArgumentUtils.findUsedArgumentTypes()

• SuggestionProviders

  • 引用位置: 方法调用
  • 关联成员: SuggestionProviders.getName()

• HolderLookup

  • 引用位置: 参数

• HolderSet

  • 引用位置: 方法调用
  • 关联成员: HolderSet.emptyNamed()

• VanillaRegistries

  • 引用位置: 方法调用
  • 关联成员: VanillaRegistries.createLookup()

• TestCommand

  • 引用位置: 方法调用
  • 关联成员: TestCommand.register()

• ClickEvent

  • 引用位置: 方法调用/构造调用
  • 关联成员: ClickEvent.SuggestCommand(), SuggestCommand()

• Component

  • 引用位置: 方法调用
  • 关联成员: Component.empty(), Component.literal(), Component.translatable()

• ComponentUtils

  • 引用位置: 方法调用
  • 关联成员: ComponentUtils.fromMessage()

• HoverEvent

  • 引用位置: 方法调用/构造调用
  • 关联成员: HoverEvent.ShowText(), ShowText()

• ClientboundCommandsPacket

  • 引用位置: 字段/构造调用
  • 关联成员: ClientboundCommandsPacket()

• AdvancementCommands

  • 引用位置: 方法调用
  • 关联成员: AdvancementCommands.register()

• AttributeCommand

  • 引用位置: 方法调用
  • 关联成员: AttributeCommand.register()

• BanIpCommands

  • 引用位置: 方法调用
  • 关联成员: BanIpCommands.register()

• BanListCommands

  • 引用位置: 方法调用
  • 关联成员: BanListCommands.register()

• BanPlayerCommands

  • 引用位置: 方法调用
  • 关联成员: BanPlayerCommands.register()

• BossBarCommands

  • 引用位置: 方法调用
  • 关联成员: BossBarCommands.register()

• ChaseCommand

  • 引用位置: 方法调用
  • 关联成员: ChaseCommand.register()

• ClearInventoryCommands

  • 引用位置: 方法调用
  • 关联成员: ClearInventoryCommands.register()

• CloneCommands

  • 引用位置: 方法调用
  • 关联成员: CloneCommands.register()

• DamageCommand

  • 引用位置: 方法调用
  • 关联成员: DamageCommand.register()

• DataPackCommand

  • 引用位置: 方法调用
  • 关联成员: DataPackCommand.register()

• DeOpCommands

  • 引用位置: 方法调用
  • 关联成员: DeOpCommands.register()

• DebugCommand

  • 引用位置: 方法调用
  • 关联成员: DebugCommand.register()

• DebugConfigCommand

  • 引用位置: 方法调用
  • 关联成员: DebugConfigCommand.register()

• DebugMobSpawningCommand

  • 引用位置: 方法调用
  • 关联成员: DebugMobSpawningCommand.register()

• DebugPathCommand

  • 引用位置: 方法调用
  • 关联成员: DebugPathCommand.register()

• DefaultGameModeCommands

  • 引用位置: 方法调用
  • 关联成员: DefaultGameModeCommands.register()

• DialogCommand

  • 引用位置: 方法调用
  • 关联成员: DialogCommand.register()

• DifficultyCommand

  • 引用位置: 方法调用
  • 关联成员: DifficultyCommand.register()

• EffectCommands

  • 引用位置: 方法调用
  • 关联成员: EffectCommands.register()

• EmoteCommands

  • 引用位置: 方法调用
  • 关联成员: EmoteCommands.register()

• EnchantCommand

  • 引用位置: 方法调用
  • 关联成员: EnchantCommand.register()

• ExecuteCommand

  • 引用位置: 方法调用
  • 关联成员: ExecuteCommand.register()

• ExperienceCommand

  • 引用位置: 方法调用
  • 关联成员: ExperienceCommand.register()

• FetchProfileCommand

  • 引用位置: 方法调用
  • 关联成员: FetchProfileCommand.register()

• FillBiomeCommand

  • 引用位置: 方法调用
  • 关联成员: FillBiomeCommand.register()

• FillCommand

  • 引用位置: 方法调用
  • 关联成员: FillCommand.register()

• ForceLoadCommand

  • 引用位置: 方法调用
  • 关联成员: ForceLoadCommand.register()

• FunctionCommand

  • 引用位置: 方法调用
  • 关联成员: FunctionCommand.register()

• GameModeCommand

  • 引用位置: 方法调用
  • 关联成员: GameModeCommand.register()

• GameRuleCommand

  • 引用位置: 方法调用
  • 关联成员: GameRuleCommand.register()

• GiveCommand

  • 引用位置: 方法调用
  • 关联成员: GiveCommand.register()

• HelpCommand

  • 引用位置: 方法调用
  • 关联成员: HelpCommand.register()

• ItemCommands

  • 引用位置: 方法调用
  • 关联成员: ItemCommands.register()

• JfrCommand

  • 引用位置: 方法调用
  • 关联成员: JfrCommand.register()

• KickCommand

  • 引用位置: 方法调用
  • 关联成员: KickCommand.register()

• KillCommand

  • 引用位置: 方法调用
  • 关联成员: KillCommand.register()

• ListPlayersCommand

  • 引用位置: 方法调用
  • 关联成员: ListPlayersCommand.register()

• LocateCommand

  • 引用位置: 方法调用
  • 关联成员: LocateCommand.register()

• LootCommand

  • 引用位置: 方法调用
  • 关联成员: LootCommand.register()

• MsgCommand

  • 引用位置: 方法调用
  • 关联成员: MsgCommand.register()

• OpCommand

  • 引用位置: 方法调用
  • 关联成员: OpCommand.register()

• PardonCommand

  • 引用位置: 方法调用
  • 关联成员: PardonCommand.register()

• PardonIpCommand

  • 引用位置: 方法调用
  • 关联成员: PardonIpCommand.register()

• ParticleCommand

  • 引用位置: 方法调用
  • 关联成员: ParticleCommand.register()

• PerfCommand

  • 引用位置: 方法调用
  • 关联成员: PerfCommand.register()

• PlaceCommand

  • 引用位置: 方法调用
  • 关联成员: PlaceCommand.register()

• PlaySoundCommand

  • 引用位置: 方法调用
  • 关联成员: PlaySoundCommand.register()

• PublishCommand

  • 引用位置: 方法调用
  • 关联成员: PublishCommand.register()

• RaidCommand

  • 引用位置: 方法调用
  • 关联成员: RaidCommand.register()

• RandomCommand

  • 引用位置: 方法调用
  • 关联成员: RandomCommand.register()

• RecipeCommand

  • 引用位置: 方法调用
  • 关联成员: RecipeCommand.register()

• ReloadCommand

  • 引用位置: 方法调用
  • 关联成员: ReloadCommand.register()

• ReturnCommand

  • 引用位置: 方法调用
  • 关联成员: ReturnCommand.register()

• RideCommand

  • 引用位置: 方法调用
  • 关联成员: RideCommand.register()

• RotateCommand

  • 引用位置: 方法调用
  • 关联成员: RotateCommand.register()

• SaveAllCommand

  • 引用位置: 方法调用
  • 关联成员: SaveAllCommand.register()

• SaveOffCommand

  • 引用位置: 方法调用
  • 关联成员: SaveOffCommand.register()

• SaveOnCommand

  • 引用位置: 方法调用
  • 关联成员: SaveOnCommand.register()

• SayCommand

  • 引用位置: 方法调用
  • 关联成员: SayCommand.register()

• ScheduleCommand

  • 引用位置: 方法调用
  • 关联成员: ScheduleCommand.register()

• ScoreboardCommand

  • 引用位置: 方法调用
  • 关联成员: ScoreboardCommand.register()

• SeedCommand

  • 引用位置: 方法调用
  • 关联成员: SeedCommand.register()

• ServerPackCommand

  • 引用位置: 方法调用
  • 关联成员: ServerPackCommand.register()

• SetBlockCommand

  • 引用位置: 方法调用
  • 关联成员: SetBlockCommand.register()

• SetPlayerIdleTimeoutCommand

  • 引用位置: 方法调用
  • 关联成员: SetPlayerIdleTimeoutCommand.register()

• SetSpawnCommand

  • 引用位置: 方法调用
  • 关联成员: SetSpawnCommand.register()

• SetWorldSpawnCommand

  • 引用位置: 方法调用
  • 关联成员: SetWorldSpawnCommand.register()

• SpawnArmorTrimsCommand

  • 引用位置: 方法调用
  • 关联成员: SpawnArmorTrimsCommand.register()

• SpectateCommand

  • 引用位置: 方法调用
  • 关联成员: SpectateCommand.register()

• SpreadPlayersCommand

  • 引用位置: 方法调用
  • 关联成员: SpreadPlayersCommand.register()

• StopCommand

  • 引用位置: 方法调用
  • 关联成员: StopCommand.register()

• StopSoundCommand

  • 引用位置: 方法调用
  • 关联成员: StopSoundCommand.register()

• StopwatchCommand

  • 引用位置: 方法调用
  • 关联成员: StopwatchCommand.register()

• SummonCommand

  • 引用位置: 方法调用
  • 关联成员: SummonCommand.register()

• SwingCommand

  • 引用位置: 方法调用
  • 关联成员: SwingCommand.register()

• TagCommand

  • 引用位置: 方法调用
  • 关联成员: TagCommand.register()

• TeamCommand

  • 引用位置: 方法调用
  • 关联成员: TeamCommand.register()

• TeamMsgCommand

  • 引用位置: 方法调用
  • 关联成员: TeamMsgCommand.register()

• TeleportCommand

  • 引用位置: 方法调用
  • 关联成员: TeleportCommand.register()

• TellRawCommand

  • 引用位置: 方法调用
  • 关联成员: TellRawCommand.register()

• TickCommand

  • 引用位置: 方法调用
  • 关联成员: TickCommand.register()

• TimeCommand

  • 引用位置: 方法调用
  • 关联成员: TimeCommand.register()

• TitleCommand

  • 引用位置: 方法调用
  • 关联成员: TitleCommand.register()

• TransferCommand

  • 引用位置: 方法调用
  • 关联成员: TransferCommand.register()

• TriggerCommand

  • 引用位置: 方法调用
  • 关联成员: TriggerCommand.register()

• VersionCommand

  • 引用位置: 方法调用
  • 关联成员: VersionCommand.register()

• WardenSpawnTrackerCommand

  • 引用位置: 方法调用
  • 关联成员: WardenSpawnTrackerCommand.register()

• WaypointCommand

  • 引用位置: 方法调用
  • 关联成员: WaypointCommand.register()

• WeatherCommand

  • 引用位置: 方法调用
  • 关联成员: WeatherCommand.register()

• WhitelistCommand

  • 引用位置: 方法调用
  • 关联成员: WhitelistCommand.register()

• WorldBorderCommand

  • 引用位置: 方法调用
  • 关联成员: WorldBorderCommand.register()

• DataCommands

  • 引用位置: 方法调用
  • 关联成员: DataCommands.register()

• ServerPlayer

  • 引用位置: 参数

• PermissionCheck

  • 引用位置: 参数/字段/方法调用/构造调用
  • 关联成员: PermissionCheck.Require(), Require()

• PermissionProviderCheck

  • 引用位置: 返回值

• PermissionSet

  • 引用位置: 参数

• PermissionSetSupplier

  • 引用位置: 返回值

• Util

  • 引用位置: 方法调用
  • 关联成员: Util.describeError()

• Profiler

  • 引用位置: 方法调用
  • 关联成员: Profiler.get()