diff options
Diffstat (limited to 'patch-remap/mache-vineflower-stripped/net/minecraft/commands/Commands.java.patch')
| -rw-r--r-- | patch-remap/mache-vineflower-stripped/net/minecraft/commands/Commands.java.patch | 192 |
1 files changed, 192 insertions, 0 deletions
diff --git a/patch-remap/mache-vineflower-stripped/net/minecraft/commands/Commands.java.patch b/patch-remap/mache-vineflower-stripped/net/minecraft/commands/Commands.java.patch new file mode 100644 index 0000000000..26b1a12ad0 --- /dev/null +++ b/patch-remap/mache-vineflower-stripped/net/minecraft/commands/Commands.java.patch @@ -0,0 +1,192 @@ +--- a/net/minecraft/commands/Commands.java ++++ b/net/minecraft/commands/Commands.java +@@ -137,6 +134,14 @@ + import net.minecraft.world.level.GameRules; + import org.slf4j.Logger; + ++// CraftBukkit start ++import com.google.common.base.Joiner; ++import java.util.Collection; ++import java.util.LinkedHashSet; ++import org.bukkit.event.player.PlayerCommandSendEvent; ++import org.bukkit.event.server.ServerCommandEvent; ++// CraftBukkit end ++ + public class Commands { + private static final ThreadLocal<ExecutionContext<CommandSourceStack>> CURRENT_EXECUTION_CONTEXT = new ThreadLocal<>(); + private static final Logger LOGGER = LogUtils.getLogger(); +@@ -148,6 +154,7 @@ + private final CommandDispatcher<CommandSourceStack> dispatcher = new CommandDispatcher<>(); + + public Commands(Commands.CommandSelection selection, CommandBuildContext context) { ++ this(); // CraftBukkit + AdvancementCommands.register(this.dispatcher); + AttributeCommand.register(this.dispatcher, context); + ExecuteCommand.register(this.dispatcher, context); +@@ -248,6 +255,11 @@ + PublishCommand.register(this.dispatcher); + } + ++ // CraftBukkit start ++ } ++ ++ public Commands() { ++ // CraftBukkkit end + this.dispatcher.setConsumer(ExecutionCommandSource.resultConsumer()); + } + +@@ -257,16 +270,66 @@ + return new ParseResults<>(commandContextBuilder, parseResults.getReader(), parseResults.getExceptions()); + } + +- public void performPrefixedCommand(CommandSourceStack commandSourceStack, String string) { +- string = string.startsWith("/") ? string.substring(1) : string; +- this.performCommand(this.dispatcher.parse(string, commandSourceStack), string); ++ // CraftBukkit start ++ public void dispatchServerCommand(CommandSourceStack sender, String command) { ++ Joiner joiner = Joiner.on(" "); ++ if (command.startsWith("/")) { ++ command = command.substring(1); ++ } ++ ++ ServerCommandEvent event = new ServerCommandEvent(sender.getBukkitSender(), command); ++ org.bukkit.Bukkit.getPluginManager().callEvent(event); ++ if (event.isCancelled()) { ++ return; ++ } ++ command = event.getCommand(); ++ ++ String[] args = command.split(" "); ++ ++ String cmd = args[0]; ++ if (cmd.startsWith("minecraft:")) cmd = cmd.substring("minecraft:".length()); ++ if (cmd.startsWith("bukkit:")) cmd = cmd.substring("bukkit:".length()); ++ ++ // Block disallowed commands ++ if (cmd.equalsIgnoreCase("stop") || cmd.equalsIgnoreCase("kick") || cmd.equalsIgnoreCase("op") ++ || cmd.equalsIgnoreCase("deop") || cmd.equalsIgnoreCase("ban") || cmd.equalsIgnoreCase("ban-ip") ++ || cmd.equalsIgnoreCase("pardon") || cmd.equalsIgnoreCase("pardon-ip") || cmd.equalsIgnoreCase("reload")) { ++ return; ++ } ++ ++ // Handle vanilla commands; ++ if (sender.getLevel().getCraftServer().getCommandBlockOverride(args[0])) { ++ args[0] = "minecraft:" + args[0]; ++ } ++ ++ String newCommand = joiner.join(args); ++ this.performPrefixedCommand(sender, newCommand, newCommand); + } ++ // CraftBukkit end + +- public void performCommand(ParseResults<CommandSourceStack> parseResults, String string) { +- CommandSourceStack commandSourceStack = parseResults.getContext().getSource(); +- commandSourceStack.getServer().getProfiler().push(() -> "/" + string); +- ContextChain<CommandSourceStack> contextChain = finishParsing(parseResults, string, commandSourceStack); ++ public void performPrefixedCommand(CommandSourceStack commandlistenerwrapper, String s) { ++ // CraftBukkit start ++ this.performPrefixedCommand(commandlistenerwrapper, s, s); ++ } + ++ public void performPrefixedCommand(CommandSourceStack commandlistenerwrapper, String s, String label) { ++ s = s.startsWith("/") ? s.substring(1) : s; ++ this.performCommand(this.dispatcher.parse(s, commandlistenerwrapper), s, label); ++ // CraftBukkit end ++ } ++ ++ public void performCommand(ParseResults<CommandSourceStack> parseresults, String s) { ++ this.performCommand(parseresults, s, s); ++ } ++ ++ public void performCommand(ParseResults<CommandSourceStack> parseresults, String s, String label) { // CraftBukkit ++ CommandSourceStack commandlistenerwrapper = (CommandSourceStack) parseresults.getContext().getSource(); ++ ++ commandlistenerwrapper.getServer().getProfiler().push(() -> { ++ return "/" + s; ++ }); ++ ContextChain contextchain = finishParsing(parseresults, s, commandlistenerwrapper, label); // CraftBukkit ++ + try { + if (contextChain != null) { + executeCommandInContext( +@@ -306,22 +362,22 @@ + } + + @Nullable +- private static ContextChain<CommandSourceStack> finishParsing( +- ParseResults<CommandSourceStack> parseResults, String string, CommandSourceStack commandSourceStack +- ) { ++ private static ContextChain<CommandSourceStack> finishParsing(ParseResults<CommandSourceStack> parseresults, String s, CommandSourceStack commandlistenerwrapper, String label) { // CraftBukkit + try { +- validateParseResults(parseResults); +- return ContextChain.tryFlatten(parseResults.getContext().build(string)) +- .orElseThrow(() -> CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand().createWithContext(parseResults.getReader())); +- } catch (CommandSyntaxException var7) { +- commandSourceStack.sendFailure(ComponentUtils.fromMessage(var7.getRawMessage())); +- if (var7.getInput() != null && var7.getCursor() >= 0) { +- int min = Math.min(var7.getInput().length(), var7.getCursor()); +- MutableComponent mutableComponent = Component.empty() +- .withStyle(ChatFormatting.GRAY) +- .withStyle(style -> style.withClickEvent(new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, "/" + string))); +- if (min > 10) { +- mutableComponent.append(CommonComponents.ELLIPSIS); ++ validateParseResults(parseresults); ++ return (ContextChain) ContextChain.tryFlatten(parseresults.getContext().build(s)).orElseThrow(() -> { ++ return CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand().createWithContext(parseresults.getReader()); ++ }); ++ } catch (CommandSyntaxException commandsyntaxexception) { ++ commandlistenerwrapper.sendFailure(ComponentUtils.fromMessage(commandsyntaxexception.getRawMessage())); ++ if (commandsyntaxexception.getInput() != null && commandsyntaxexception.getCursor() >= 0) { ++ int i = Math.min(commandsyntaxexception.getInput().length(), commandsyntaxexception.getCursor()); ++ MutableComponent ichatmutablecomponent = Component.empty().withStyle(ChatFormatting.GRAY).withStyle((chatmodifier) -> { ++ return chatmodifier.withClickEvent(new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, label)); // CraftBukkit ++ }); ++ ++ if (i > 10) { ++ ichatmutablecomponent.append(CommonComponents.ELLIPSIS); + } + + mutableComponent.append(var7.getInput().substring(Math.max(0, min - 10), min)); +@@ -359,11 +432,37 @@ + } + + public void sendCommands(ServerPlayer player) { +- Map<CommandNode<CommandSourceStack>, CommandNode<SharedSuggestionProvider>> map = Maps.newHashMap(); +- RootCommandNode<SharedSuggestionProvider> rootCommandNode = new RootCommandNode<>(); +- map.put(this.dispatcher.getRoot(), rootCommandNode); +- this.fillUsableCommands(this.dispatcher.getRoot(), rootCommandNode, player.createCommandSourceStack(), map); +- player.connection.send(new ClientboundCommandsPacket(rootCommandNode)); ++ // CraftBukkit start ++ // Register Vanilla commands into builtRoot as before ++ Map<CommandNode<CommandSourceStack>, CommandNode<SharedSuggestionProvider>> map = Maps.newIdentityHashMap(); // Use identity to prevent aliasing issues ++ RootCommandNode vanillaRoot = new RootCommandNode(); ++ ++ RootCommandNode<CommandSourceStack> vanilla = player.server.vanillaCommandDispatcher.getDispatcher().getRoot(); ++ map.put(vanilla, vanillaRoot); ++ this.fillUsableCommands(vanilla, vanillaRoot, player.createCommandSourceStack(), (Map) map); ++ ++ // Now build the global commands in a second pass ++ RootCommandNode<SharedSuggestionProvider> rootcommandnode = new RootCommandNode(); ++ ++ map.put(this.dispatcher.getRoot(), rootcommandnode); ++ this.fillUsableCommands(this.dispatcher.getRoot(), rootcommandnode, player.createCommandSourceStack(), map); ++ ++ Collection<String> bukkit = new LinkedHashSet<>(); ++ for (CommandNode node : rootcommandnode.getChildren()) { ++ bukkit.add(node.getName()); ++ } ++ ++ PlayerCommandSendEvent event = new PlayerCommandSendEvent(player.getBukkitEntity(), new LinkedHashSet<>(bukkit)); ++ event.getPlayer().getServer().getPluginManager().callEvent(event); ++ ++ // Remove labels that were removed during the event ++ for (String orig : bukkit) { ++ if (!event.getCommands().contains(orig)) { ++ rootcommandnode.removeCommand(orig); ++ } ++ } ++ // CraftBukkit end ++ player.connection.send(new ClientboundCommandsPacket(rootcommandnode)); + } + + private void fillUsableCommands( |