Plexus/Plex
1
0
Fork 0
mirror of https://github.com/plexusorg/Plex.git synced 2026-06-04 05:26:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Brigadier

Browse Source
This commit is contained in:
Telesphoreo
2026-05-19 19:01:22 -04:00
parent 3da6b2972e
commit 66476fe110
52 changed files with 1117 additions and 1172 deletions
Download Patch File Download Diff File Expand all files Collapse all files
api/src/main/java/dev/plex/api/command/CommandApi.java
+3 -3
View File
@@ -1,10 +1,10 @@
package dev.plex.api.command;
import org.bukkit.command.Command;
import dev.plex.command.PlexCommand;
public interface CommandApi
{
void register(Command command);
void register(PlexCommand command);
void unregister(Command command);
void unregister(PlexCommand command);
}
api/src/main/java/dev/plex/command/PlexCommand.java
+38 -270
View File
@@ -1,307 +1,75 @@
package dev.plex.command;
import java.util.ArrayList;
import com.mojang.brigadier.tree.LiteralCommandNode;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.exception.CommandFailException;
import dev.plex.command.exception.ConsoleMustDefinePlayerException;
import dev.plex.command.exception.ConsoleOnlyException;
import dev.plex.command.exception.PlayerNotBannedException;
import dev.plex.command.exception.PlayerNotFoundException;
import dev.plex.command.source.RequiredCommandSource;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
import net.kyori.adventure.audience.Audience;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.command.Command;
import org.bukkit.command.CommandMap;
import org.bukkit.command.CommandSender;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.entity.Player;
import org.bukkit.util.StringUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/** Public base class for module commands. */
public abstract class PlexCommand extends Command
/**
* Public Brigadier command contract for Plex and Plex modules.
*/
public interface PlexCommand
{
private static Runtime runtime;
private final CommandParameters params;
private final CommandPermissions perms;
private final RequiredCommandSource commandSource;
LiteralCommandNode<CommandSourceStack> buildCommand();
public static void setRuntime(Runtime runtime)
default CommandParameters parameters()
{
PlexCommand.runtime = runtime;
CommandParameters parameters = getClass().getAnnotation(CommandParameters.class);
if (parameters == null)
{
throw new IllegalStateException(getClass().getName() + " requires a CommandParameters annotation");
}
return parameters;
}
public PlexCommand(boolean register)
default CommandPermissions permissions()
{
super("");
this.params = getClass().getAnnotation(CommandParameters.class);
this.perms = getClass().getAnnotation(CommandPermissions.class);
if (params == null || perms == null)
CommandPermissions permissions = getClass().getAnnotation(CommandPermissions.class);
if (permissions == null)
{
throw new IllegalStateException("PlexCommand requires CommandParameters and CommandPermissions annotations");
}
setName(params.name());
setLabel(params.name());
setDescription(params.description());
setPermission(perms.permission());
setUsage(params.usage().replace("<command>", params.name()));
if (!params.aliases().isEmpty())
{
setAliases(Arrays.asList(params.aliases().split(",")));
}
this.commandSource = perms.source();
if (register)
{
requireRuntime().register(this);
throw new IllegalStateException(getClass().getName() + " requires a CommandPermissions annotation");
}
return permissions;
}
public PlexCommand()
default String getName()
{
this(true);
return parameters().name();
}
protected abstract Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args);
@Override
public boolean execute(@NotNull CommandSender sender, @NotNull String label, String[] args)
default String getDescription()
{
if (!matches(label))
{
return false;
}
if (commandSource == RequiredCommandSource.CONSOLE && sender instanceof Player)
{
send(sender, messageComponent("noPermissionInGame"));
return true;
}
if (commandSource == RequiredCommandSource.IN_GAME && sender instanceof ConsoleCommandSender)
{
send(sender, messageComponent("noPermissionConsole"));
return true;
}
if (!perms.permission().isEmpty() && sender instanceof Player player && !player.hasPermission(perms.permission()))
{
send(sender, messageComponent("noPermissionNode", perms.permission()));
return true;
}
try
{
Component component = execute(sender, isConsole(sender) ? null : (Player)sender, args);
if (component != null)
{
send(sender, component);
}
}
catch (PlayerNotFoundException | CommandFailException | ConsoleOnlyException |
ConsoleMustDefinePlayerException | PlayerNotBannedException | NumberFormatException ex)
{
send(sender, exceptionComponent(ex));
}
return true;
return parameters().description();
}
@NotNull
public abstract List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException;
@NotNull
@Override
public List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
default String getUsage()
{
return StringUtil.copyPartialMatches(args[args.length - 1], smartTabComplete(sender, alias, args), new ArrayList<>());
return parameters().usage().replace("<command>", getName());
}
private boolean matches(String label)
default String getPermission()
{
return getName().equalsIgnoreCase(label) || getAliases().stream().anyMatch(alias -> alias.equalsIgnoreCase(label));
return permissions().permission();
}
protected void send(Audience audience, String s)
default RequiredCommandSource getRequiredSource()
{
audience.sendMessage(componentFromString(s));
return permissions().source();
}
protected void send(Audience audience, Component component)
default List<String> getAliases()
{
audience.sendMessage(component);
String aliases = parameters().aliases();
if (aliases.isBlank())
{
return List.of();
}
protected boolean checkPermission(CommandSender sender, String permission)
{
return isConsole(sender) || checkPermission((Player)sender, permission);
}
protected boolean silentCheckPermission(CommandSender sender, String permission)
{
return isConsole(sender) || silentCheckPermission((Player)sender, permission);
}
protected boolean checkPermission(Player player, String permission)
{
if (!permission.isEmpty() && !player.hasPermission(permission))
{
throw new CommandFailException(messageString("noPermissionNode", permission));
}
return true;
}
protected boolean silentCheckPermission(Player player, String permission)
{
return permission.isEmpty() || player.hasPermission(permission);
}
protected UUID getUUID(CommandSender sender)
{
return sender instanceof Player player ? player.getUniqueId() : null;
}
protected boolean isConsole(CommandSender sender)
{
return !(sender instanceof Player);
}
protected Component messageComponent(String s, Object... objects)
{
return requireRuntime().messageComponent(s, objects);
}
protected Component messageComponent(String s, Component... objects)
{
return requireRuntime().messageComponent(s, objects);
}
@Override
public Component permissionMessage()
{
return messageComponent("noPermissionNode", getPermission());
}
protected String messageString(String s, Object... objects)
{
return requireRuntime().messageString(s, objects);
}
protected Component usage()
{
return messageComponent("correctUsagePrefix").append(componentFromString(getUsage()).color(NamedTextColor.GRAY));
}
protected Component usage(String s)
{
return messageComponent("correctUsagePrefix").append(componentFromString(s).color(NamedTextColor.GRAY));
}
private Component exceptionComponent(RuntimeException ex)
{
if (ex instanceof PlayerNotFoundException && "PlayerNotFoundException".equals(ex.getMessage()))
{
return messageComponent("playerNotFound");
}
if (ex instanceof PlayerNotBannedException && "PlayerNotBannedException".equals(ex.getMessage()))
{
return messageComponent("playerNotBanned");
}
if (ex instanceof ConsoleOnlyException && "ConsoleOnlyException".equals(ex.getMessage()))
{
return messageComponent("consoleOnly");
}
if (ex instanceof ConsoleMustDefinePlayerException && "ConsoleMustDefinePlayerException".equals(ex.getMessage()))
{
return messageComponent("consoleMustDefinePlayer");
}
return mmString(ex.getMessage());
}
protected Player getNonNullPlayer(String name)
{
Player player;
try
{
player = Bukkit.getPlayer(UUID.fromString(name));
}
catch (IllegalArgumentException ignored)
{
player = Bukkit.getPlayer(name);
}
if (player == null)
{
throw new PlayerNotFoundException();
}
return player;
}
protected World getNonNullWorld(String name)
{
World world = Bukkit.getWorld(name);
if (world == null)
{
throw new CommandFailException(messageString("worldNotFound"));
}
return world;
}
protected Component componentFromString(String s)
{
return LegacyComponentSerializer.legacyAmpersand().deserialize(s).colorIfAbsent(NamedTextColor.GRAY);
}
protected Component noColorComponentFromString(String s)
{
return LegacyComponentSerializer.legacyAmpersand().deserialize(s);
}
protected Component mmString(String s)
{
return requireRuntime().miniMessage(s);
}
protected void broadcast(String miniMessage)
{
requireRuntime().broadcast(miniMessage);
}
protected void broadcast(Component component)
{
requireRuntime().broadcast(component);
}
protected List<String> onlinePlayerNames()
{
return requireRuntime().onlinePlayerNames();
}
public CommandMap getMap()
{
return Bukkit.getCommandMap();
}
private static Runtime requireRuntime()
{
if (runtime == null)
{
throw new IllegalStateException("PlexCommand runtime has not been installed by Plex");
}
return runtime;
}
public interface Runtime
{
void register(Command command);
Component messageComponent(String entry, Object... objects);
Component messageComponent(String entry, Component... objects);
String messageString(String entry, Object... objects);
Component miniMessage(String input);
void broadcast(String miniMessage);
void broadcast(Component component);
List<String> onlinePlayerNames();
return Arrays.stream(aliases.split(","))
.map(String::trim)
.filter(alias -> !alias.isBlank())
.toList();
}
}
api/src/main/java/dev/plex/module/PlexModule.java
+6 -6
View File
@@ -1,6 +1,7 @@
package dev.plex.module;
import dev.plex.api.PlexApi;
import dev.plex.command.PlexCommand;
import java.io.File;
import java.io.IOException;
@@ -13,7 +14,6 @@ import java.util.List;
import java.util.Locale;
import org.apache.logging.log4j.Logger;
import org.bukkit.command.Command;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
import org.jetbrains.annotations.NotNull;
@@ -27,7 +27,7 @@ import org.jetbrains.annotations.Nullable;
*/
public abstract class PlexModule
{
private final List<Command> commands = new ArrayList<>();
private final List<PlexCommand> commands = new ArrayList<>();
private final List<Listener> listeners = new ArrayList<>();
private PlexApi api;
@@ -72,7 +72,7 @@ public abstract class PlexModule
HandlerList.unregisterAll(listener);
}
public void registerCommand(Command command)
public void registerCommand(PlexCommand command)
{
commands.add(command);
if (api != null)
@@ -81,7 +81,7 @@ public abstract class PlexModule
}
}
public void unregisterCommand(Command command)
public void unregisterCommand(PlexCommand command)
{
commands.remove(command);
if (api != null)
@@ -91,7 +91,7 @@ public abstract class PlexModule
}
@Nullable
public Command getCommand(String name)
public PlexCommand getCommand(String name)
{
return commands.stream()
.filter(command -> command.getName().equalsIgnoreCase(name) || command.getAliases().stream().map(String::toLowerCase).toList().contains(name.toLowerCase(Locale.ROOT)))
@@ -142,7 +142,7 @@ public abstract class PlexModule
}
}
public List<Command> getCommands()
public List<PlexCommand> getCommands()
{
return commands;
}
server/src/main/java/dev/plex/Plex.java
+5 -57
View File
@@ -35,6 +35,8 @@ import dev.plex.util.redis.MessageUtil;
import dev.plex.world.CustomWorld;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import lombok.Getter;
import lombok.Setter;
@@ -69,6 +71,8 @@ public class Plex extends JavaPlugin
private NoteRepository noteRepository;
private ModuleManager moduleManager;
private CommandHandler commandHandler;
private final List<PlexCommand> pendingCommands = new ArrayList<>();
private ServiceManager serviceManager;
private PunishmentManager punishmentManager;
private UpdateChecker updateChecker;
@@ -121,62 +125,6 @@ public class Plex extends JavaPlugin
{
return Plex.this;
}
@Override
public void register(org.bukkit.command.Command command)
{
api.commands().register(command);
}
});
PlexCommand.setRuntime(new PlexCommand.Runtime()
{
@Override
public void register(org.bukkit.command.Command command)
{
api.commands().register(command);
}
@Override
public net.kyori.adventure.text.Component messageComponent(String entry, Object... objects)
{
return api.messages().messageComponent(entry, objects);
}
@Override
public net.kyori.adventure.text.Component messageComponent(String entry, net.kyori.adventure.text.Component... objects)
{
return api.messages().messageComponent(entry, objects);
}
@Override
public String messageString(String entry, Object... objects)
{
return api.messages().messageString(entry, objects);
}
@Override
public net.kyori.adventure.text.Component miniMessage(String input)
{
return api.messages().miniMessage(input);
}
@Override
public void broadcast(String miniMessage)
{
api.messages().broadcast(miniMessage);
}
@Override
public void broadcast(net.kyori.adventure.text.Component component)
{
api.messages().broadcast(component);
}
@Override
public java.util.List<String> onlinePlayerNames()
{
return api.players().onlineNames();
}
});
ModuleConfig.setFactory((module, from, to) -> api.moduleConfigs().create(module, from, to));
}
@@ -273,7 +221,7 @@ public class Plex extends JavaPlugin
playerService = new PlayerService(playerCache, playerRepository);
new ListenerHandler(this);
new CommandHandler(this);
commandHandler = new CommandHandler(this);
punishmentManager = new PunishmentManager(this);
punishmentManager.mergeIndefiniteBans();
server/src/main/java/dev/plex/api/impl/DefaultCommandApi.java
+15 -9
View File
@@ -2,7 +2,8 @@ package dev.plex.api.impl;
import dev.plex.Plex;
import dev.plex.api.command.CommandApi;
import org.bukkit.command.Command;
import dev.plex.command.PlexCommand;
import dev.plex.util.PlexLog;
final class DefaultCommandApi implements CommandApi
{
@@ -11,18 +12,23 @@ final class DefaultCommandApi implements CommandApi
DefaultCommandApi(Plex plugin) { this.plugin = plugin; }
@Override
public void register(Command command)
public void register(PlexCommand command)
{
plugin.getServer().getCommandMap().getKnownCommands().remove(command.getName().toLowerCase());
command.getAliases().forEach(alias -> plugin.getServer().getCommandMap().getKnownCommands().remove(alias.toLowerCase()));
plugin.getServer().getCommandMap().register("plex", command);
if (plugin.getCommandHandler() == null)
{
plugin.getPendingCommands().add(command);
PlexLog.warn("Command {0} was registered before the command handler initialized; queueing it for Brigadier registration.", command.getName());
return;
}
plugin.getCommandHandler().registerCommand(command);
}
@Override
public void unregister(Command command)
public void unregister(PlexCommand command)
{
plugin.getServer().getCommandMap().getKnownCommands().remove(command.getName().toLowerCase());
command.getAliases().forEach(alias -> plugin.getServer().getCommandMap().getKnownCommands().remove(alias.toLowerCase()));
command.unregister(plugin.getServer().getCommandMap());
if (plugin.getCommandHandler() != null)
{
plugin.getCommandHandler().unregisterCommand(command);
}
}
}
server/src/main/java/dev/plex/command/ServerCommand.java
+277 -267
View File
@@ -1,9 +1,16 @@
package dev.plex.command;
import com.google.common.collect.Lists;
import com.mojang.brigadier.arguments.IntegerArgumentType;
import com.mojang.brigadier.arguments.StringArgumentType;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import com.mojang.brigadier.builder.RequiredArgumentBuilder;
import com.mojang.brigadier.context.CommandContext;
import com.mojang.brigadier.suggestion.SuggestionProvider;
import com.mojang.brigadier.suggestion.Suggestions;
import com.mojang.brigadier.suggestion.SuggestionsBuilder;
import com.mojang.brigadier.tree.LiteralCommandNode;
import dev.plex.Plex;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.exception.CommandFailException;
import dev.plex.command.exception.ConsoleMustDefinePlayerException;
import dev.plex.command.exception.ConsoleOnlyException;
@@ -13,52 +20,34 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.player.PlexPlayer;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import java.util.Arrays;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import io.papermc.paper.command.brigadier.Commands;
import java.util.Collection;
import java.util.Locale;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.function.Supplier;
import net.kyori.adventure.audience.Audience;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.command.Command;
import org.bukkit.command.CommandMap;
import org.bukkit.command.CommandSender;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.command.PluginIdentifiableCommand;
import org.bukkit.entity.Player;
import org.bukkit.util.StringUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* Superclass for all server commands.
* Brigadier-backed superclass for Plex's built-in server commands.
*/
public abstract class ServerCommand extends Command implements PluginIdentifiableCommand
public abstract class ServerCommand implements PlexCommand
{
private static Runtime runtime;
/**
* Returns the instance of the plugin
*/
protected final Plex plugin;
/**
* The parameters for the command
*/
private final CommandParameters params;
/**
* The permissions for the command
*/
private final CommandPermissions perms;
/**
* Required command source fetched from the permissions
*/
private final RequiredCommandSource commandSource;
public static void setRuntime(Runtime runtime)
@@ -66,102 +55,233 @@ public abstract class ServerCommand extends Command implements PluginIdentifiabl
ServerCommand.runtime = runtime;
}
/**
* Creates an instance of the command
*/
public ServerCommand(boolean register)
protected ServerCommand()
{
super("");
this.plugin = requireRuntime().plugin();
this.params = getClass().getAnnotation(CommandParameters.class);
this.perms = getClass().getAnnotation(CommandPermissions.class);
setName(this.params.name());
setLabel(this.params.name());
setDescription(params.description());
setPermission(this.perms.permission());
setUsage(params.usage().replace("<command>", this.params.name()));
if (params.aliases().split(",").length > 0)
{
setAliases(Arrays.asList(params.aliases().split(",")));
}
this.commandSource = perms.source();
if (register)
{
requireRuntime().register(this);
}
this.commandSource = permissions().source();
}
public ServerCommand()
{
this(true);
}
/**
* Executes the command
*
* @param sender The sender of the command
* @param playerSender The player who executed the command (null if CommandSource is console or if CommandSource is any but console executed)
* @param args A Kyori Component to send to the sender (can be null)
*/
protected abstract Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args);
/**
* @hidden
*/
@Override
public boolean execute(@NotNull CommandSender sender, @NotNull String label, String[] args)
public final LiteralCommandNode<CommandSourceStack> buildCommand()
{
if (!matches(label))
LiteralArgumentBuilder<CommandSourceStack> command = Commands.literal(getName())
.requires(this::canUse);
buildCommand(command);
return command.build();
}
protected abstract void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command);
protected LiteralArgumentBuilder<CommandSourceStack> literal(String literal)
{
return Commands.literal(literal);
}
protected RequiredArgumentBuilder<CommandSourceStack, String> word(String name)
{
return Commands.argument(name, StringArgumentType.word());
}
protected RequiredArgumentBuilder<CommandSourceStack, String> playerArgument(String name)
{
return word(name).suggests(suggestPlayers());
}
protected RequiredArgumentBuilder<CommandSourceStack, String> greedyString(String name)
{
return Commands.argument(name, StringArgumentType.greedyString());
}
protected RequiredArgumentBuilder<CommandSourceStack, Integer> nonNegativeInteger(String name)
{
return Commands.argument(name, IntegerArgumentType.integer(0));
}
protected int executeCommand(CommandContext<CommandSourceStack> context, String... args)
{
return dispatchCommand(context, args);
}
protected String string(CommandContext<CommandSourceStack> context, String name)
{
return StringArgumentType.getString(context, name);
}
protected int integer(CommandContext<CommandSourceStack> context, String name)
{
return IntegerArgumentType.getInteger(context, name);
}
protected String[] argsWithGreedy(String greedy)
{
return splitExecutionArgs(greedy);
}
protected String[] argsWithGreedy(String first, String greedy)
{
String[] greedyArgs = argsWithGreedy(greedy);
String[] args = new String[greedyArgs.length + 1];
args[0] = first;
System.arraycopy(greedyArgs, 0, args, 1, greedyArgs.length);
return args;
}
protected String[] argsWithGreedy(String first, String second, String greedy)
{
String[] greedyArgs = argsWithGreedy(greedy);
String[] args = new String[greedyArgs.length + 2];
args[0] = first;
args[1] = second;
System.arraycopy(greedyArgs, 0, args, 2, greedyArgs.length);
return args;
}
protected SuggestionProvider<CommandSourceStack> suggest(Supplier<Collection<String>> suggestions)
{
return (context, builder) -> suggestMatching(builder, suggestions.get());
}
protected SuggestionProvider<CommandSourceStack> suggest(Collection<String> suggestions)
{
return (context, builder) -> suggestMatching(builder, suggestions);
}
protected SuggestionProvider<CommandSourceStack> suggestGreedyWords(Supplier<Collection<String>> suggestions)
{
return (context, builder) -> suggestLastGreedyToken(builder, suggestions.get());
}
protected SuggestionProvider<CommandSourceStack> suggestGreedyWords(Collection<String> suggestions)
{
return (context, builder) -> suggestLastGreedyToken(builder, suggestions);
}
protected CompletableFuture<Suggestions> suggestMatching(SuggestionsBuilder builder, Collection<String> suggestions)
{
String remaining = builder.getRemaining().toLowerCase(Locale.ROOT);
for (String suggestion : suggestions)
{
if (suggestion.toLowerCase(Locale.ROOT).startsWith(remaining))
{
builder.suggest(suggestion);
}
}
return builder.buildFuture();
}
protected CompletableFuture<Suggestions> suggestLastGreedyToken(SuggestionsBuilder builder, Collection<String> suggestions)
{
String remaining = builder.getRemaining();
int tokenStart = remaining.lastIndexOf(' ') + 1;
SuggestionsBuilder tokenBuilder = tokenStart == 0 ? builder : builder.createOffset(builder.getStart() + tokenStart);
return suggestMatching(tokenBuilder, suggestions);
}
protected CompletableFuture<Suggestions> suggestOptionalFlags(SuggestionsBuilder builder, Collection<String> flags)
{
String remaining = builder.getRemaining();
if (remaining.isBlank())
{
return builder.buildFuture();
}
List<String> availableFlags = Lists.newArrayList(flags);
for (String token : remaining.split("\\s+"))
{
if (token.isBlank())
{
continue;
}
if (flags.stream().anyMatch(flag -> flag.equalsIgnoreCase(token)))
{
availableFlags.removeIf(flag -> flag.equalsIgnoreCase(token));
}
}
String currentToken = remaining.substring(remaining.lastIndexOf(' ') + 1);
if (!currentToken.startsWith("-"))
{
return builder.buildFuture();
}
return suggestLastGreedyToken(builder, availableFlags);
}
protected SuggestionProvider<CommandSourceStack> suggestPlayers()
{
return suggest(PlexUtils::getPlayerNameList);
}
protected SuggestionProvider<CommandSourceStack> suggestPlayersAndAll()
{
return suggest(() ->
{
List<String> suggestions = Lists.newArrayList(PlexUtils.getPlayerNameList());
suggestions.add("-a");
return suggestions;
});
}
protected SuggestionProvider<CommandSourceStack> suggestPlayersAndAll(String permission)
{
return (context, builder) ->
{
if (!silentCheckPermission(context.getSource().getSender(), permission))
{
return builder.buildFuture();
}
List<String> suggestions = Lists.newArrayList(PlexUtils.getPlayerNameList());
suggestions.add("-a");
return suggestMatching(builder, suggestions);
};
}
private boolean canUse(CommandSourceStack source)
{
CommandSender sender = source.getSender();
if (commandSource == RequiredCommandSource.CONSOLE && sender instanceof Player)
{
return false;
}
if (commandSource == RequiredCommandSource.CONSOLE && sender instanceof Player)
if (commandSource == RequiredCommandSource.IN_GAME && sender instanceof ConsoleCommandSender)
{
sender.sendMessage(messageComponent("noPermissionInGame"));
return true;
return false;
}
if (commandSource == RequiredCommandSource.IN_GAME)
String permission = getPermission();
if (permission.isEmpty())
{
if (sender instanceof ConsoleCommandSender)
{
send(sender, messageComponent("noPermissionConsole"));
return true;
}
return !(sender instanceof Player player) || hasCachedPlexPlayer(player);
}
if (sender instanceof Player player)
{
PlexPlayer plexPlayer = plugin.getPlayerCache().getPlexPlayerMap().get(player.getUniqueId());
if (plexPlayer == null)
{
return false;
return hasCachedPlexPlayer(player) && player.hasPermission(permission);
}
if (!perms.permission().isEmpty() && !player.hasPermission(perms.permission()))
{
send(sender, messageComponent("noPermissionNode", perms.permission()));
return true;
}
}
if (sender instanceof ConsoleCommandSender && !sender.getName().equalsIgnoreCase("console")) //telnet
if (sender instanceof ConsoleCommandSender && !sender.getName().equalsIgnoreCase("console"))
{
PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(sender.getName());
Player player = plexPlayer == null ? null : Bukkit.getPlayer(plexPlayer.getName());
return player != null && plugin.getPermissions().playerHas(null, player, permission);
}
if (!perms.permission().isEmpty() && !plugin.getPermissions().playerHas(null, Bukkit.getPlayer(plexPlayer.getName()), perms.permission()))
{
send(sender, messageComponent("noPermissionNode", perms.permission()));
return true;
}
private int dispatchCommand(CommandContext<CommandSourceStack> context, String[] args)
{
CommandSender sender = context.getSource().getSender();
if (!validateSourceAndPermission(sender))
{
return com.mojang.brigadier.Command.SINGLE_SUCCESS;
}
try
{
Component component = this.execute(sender, isConsole(sender) ? null : (Player) sender, args);
Component component = this.execute(sender, isConsole(sender) ? null : (Player)sender, args);
if (component != null)
{
send(sender, component);
@@ -172,125 +292,107 @@ public abstract class ServerCommand extends Command implements PluginIdentifiabl
{
send(sender, exceptionComponent(ex));
}
return true;
return com.mojang.brigadier.Command.SINGLE_SUCCESS;
}
@NotNull
public abstract List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException;
@NotNull
@Override
public List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
private boolean validateSourceAndPermission(CommandSender sender)
{
List<String> list = smartTabComplete(sender, alias, args);
return StringUtil.copyPartialMatches(args[args.length - 1], list, Lists.newArrayList());
}
/**
* Checks if the String given is a matching command
*
* @param label The String to check
* @return true if the string is a command name or alias
*/
private boolean matches(String label)
if (commandSource == RequiredCommandSource.CONSOLE && sender instanceof Player)
{
if (params.aliases().split(",").length > 0)
{
for (String alias : params.aliases().split(","))
{
if (alias.equalsIgnoreCase(label) || getName().equalsIgnoreCase(label))
{
return true;
}
}
}
else if (params.aliases().split(",").length < 1)
{
return getName().equalsIgnoreCase(label);
}
send(sender, messageComponent("noPermissionInGame"));
return false;
}
/**
* Gets a PlexPlayer from Player object
*
* @param player The player object
* @return PlexPlayer Object
* @see PlexPlayer
*/
if (commandSource == RequiredCommandSource.IN_GAME && sender instanceof ConsoleCommandSender)
{
send(sender, messageComponent("noPermissionConsole"));
return false;
}
String permission = getPermission();
if (permission.isEmpty())
{
return true;
}
if (sender instanceof Player player)
{
if (!hasCachedPlexPlayer(player))
{
return false;
}
if (!player.hasPermission(permission))
{
send(sender, messageComponent("noPermissionNode", permission));
return false;
}
return true;
}
if (sender instanceof ConsoleCommandSender && !sender.getName().equalsIgnoreCase("console"))
{
PlexPlayer plexPlayer = plugin.getPlayerService().getPlayer(sender.getName());
Player player = plexPlayer == null ? null : Bukkit.getPlayer(plexPlayer.getName());
if (player == null || !plugin.getPermissions().playerHas(null, player, permission))
{
send(sender, messageComponent("noPermissionNode", permission));
return false;
}
}
return true;
}
private boolean hasCachedPlexPlayer(Player player)
{
return plugin.getPlayerCache().getPlexPlayerMap().containsKey(player.getUniqueId());
}
private String[] splitExecutionArgs(String rawArgs)
{
if (rawArgs.isBlank())
{
return new String[0];
}
return rawArgs.trim().split("\\s+");
}
protected PlexPlayer getPlexPlayer(@NotNull Player player)
{
return plugin.getPlayerService().getPlayer(player.getUniqueId());
}
/**
* Sends a message to an Audience
*
* @param audience The Audience to send the message to
* @param s The message to send
*/
protected void send(Audience audience, String s)
{
audience.sendMessage(componentFromString(s));
}
/**
* Sends a message to an Audience
*
* @param audience The Audience to send the message to
* @param component The Component to send
*/
protected void send(Audience audience, Component component)
{
audience.sendMessage(component);
}
/**
* Checks whether a sender has enough permissions or is high enough a rank
*
* @param sender A CommandSender
* @param permission The permission to check
* @return true if the sender has enough permissions
*/
protected boolean checkPermission(CommandSender sender, String permission)
{
if (!isConsole(sender))
{
return checkPermission((Player) sender, permission);
return checkPermission((Player)sender, permission);
}
return true;
}
/**
* Checks whether a sender has enough permissions or is high enough a rank
*
* @param sender A CommandSender
* @param permission The permission to check
* @return true if the sender has enough permissions
*/
protected boolean silentCheckPermission(CommandSender sender, String permission)
{
PlexLog.debug("Checking {0} with {1}", sender.getName(), permission);
if (!isConsole(sender))
{
return silentCheckPermission((Player) sender, permission);
return silentCheckPermission((Player)sender, permission);
}
return true;
}
/**
* Checks whether a player has enough permissions or is high enough a rank
*
* @param player The player object
* @param permission The permission to check
* @return true if the sender has enough permissions
*/
protected boolean checkPermission(Player player, String permission)
{
if (player instanceof ConsoleCommandSender)
{
return true;
}
if (!permission.isEmpty() && !player.hasPermission(permission))
{
throw new CommandFailException(PlexUtils.messageString("noPermissionNode", permission));
@@ -300,16 +402,9 @@ public abstract class ServerCommand extends Command implements PluginIdentifiabl
protected boolean silentCheckPermission(Player player, String permission)
{
return !permission.isEmpty() && player.hasPermission(permission);
return permission.isEmpty() || player.hasPermission(permission);
}
/**
* Gets the UUID of the sender
*
* @param sender A command sender
* @return A unique ID or null if the sender is console
* @see UUID
*/
protected UUID getUUID(CommandSender sender)
{
if (!(sender instanceof Player player))
@@ -319,82 +414,36 @@ public abstract class ServerCommand extends Command implements PluginIdentifiabl
return player.getUniqueId();
}
/**
* The plugin
*
* @return The instance of the plugin
* @see Plex
*/
@Override
public @NotNull Plex getPlugin()
{
return plugin;
}
/**
* Checks whether a sender is console
*
* @param sender A command sender
* @return true if the sender is console
*/
protected boolean isConsole(CommandSender sender)
{
return !(sender instanceof Player);
}
/**
* Converts a message entry from the "messages.yml" to a Component
*
* @param s The message entry
* @param objects Any objects to replace in order
* @return A Kyori Component
*/
protected Component messageComponent(String s, Object... objects)
{
return PlexUtils.messageComponent(s, objects);
}
/**
* Converts a message entry from the "messages.yml" to a Component
*
* @param s The message entry
* @param objects Any objects to replace in order
* @return A Kyori Component
*/
protected Component messageComponent(String s, Component... objects)
{
return PlexUtils.messageComponent(s, objects);
}
/**
* Converts a message entry from the "messages.yml" to a String
*
* @param s The message entry
* @param objects Any objects to replace in order
* @return A String
*/
protected String messageString(String s, Object... objects)
{
return PlexUtils.messageString(s, objects);
}
/**
* Converts usage to a Component
*
* @return A Kyori Component stating the usage
*/
protected Component usage()
{
return messageComponent("correctUsagePrefix").append(componentFromString(this.getUsage()).color(NamedTextColor.GRAY));
}
/**
* Converts usage to a Component
* <p>
* s The usage to convert
*
* @return A Kyori Component stating the usage
*/
protected Component usage(String s)
{
return messageComponent("correctUsagePrefix").append(componentFromString(s).color(NamedTextColor.GRAY));
@@ -418,7 +467,8 @@ public abstract class ServerCommand extends Command implements PluginIdentifiabl
{
return messageComponent("consoleMustDefinePlayer");
}
return PlexUtils.mmDeserialize(ex.getMessage());
String message = ex.getMessage();
return message == null ? componentFromString(ex.getClass().getSimpleName()) : PlexUtils.mmDeserialize(message);
}
protected Player getNonNullPlayer(String name)
@@ -430,7 +480,6 @@ public abstract class ServerCommand extends Command implements PluginIdentifiabl
}
catch (IllegalArgumentException ignored)
{
}
Player player = Bukkit.getPlayer(name);
@@ -472,12 +521,6 @@ public abstract class ServerCommand extends Command implements PluginIdentifiabl
return world;
}
/**
* Converts a String to a legacy Kyori Component
*
* @param s The String to convert
* @return A Kyori component
*/
protected Component componentFromString(String s)
{
return LegacyComponentSerializer.legacyAmpersand().deserialize(s).colorIfAbsent(NamedTextColor.GRAY);
@@ -488,55 +531,22 @@ public abstract class ServerCommand extends Command implements PluginIdentifiabl
return LegacyComponentSerializer.legacyAmpersand().deserialize(s);
}
/**
* Converts a String to a MiniMessage Component
*
* @param s The String to convert
* @return A Kyori Component
*/
protected Component mmString(String s)
{
return PlexUtils.mmDeserialize(s);
}
public CommandMap getMap()
{
return plugin.getServer().getCommandMap();
}
private static Runtime requireRuntime()
{
if (runtime == null)
{
Plex plex = Plex.get();
if (plex == null)
{
throw new IllegalStateException("ServerCommand runtime has not been installed by Plex");
}
return new Runtime()
{
@Override
public Plex plugin()
{
return plex;
}
@Override
public void register(Command command)
{
plex.getServer().getCommandMap().getKnownCommands().remove(command.getName().toLowerCase());
command.getAliases().forEach(alias -> plex.getServer().getCommandMap().getKnownCommands().remove(alias.toLowerCase()));
plex.getServer().getCommandMap().register("plex", command);
}
};
}
return runtime;
}
public interface Runtime
{
Plex plugin();
void register(Command command);
}
}
server/src/main/java/dev/plex/command/impl/AdminChatCMD.java
+10 -7
View File
@@ -1,5 +1,6 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -11,10 +12,9 @@ import dev.plex.util.PlexUtils;
import dev.plex.util.minimessage.SafeMiniMessage;
import dev.plex.util.redis.MessageUtil;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.command.CommandSender;
@@ -26,6 +26,14 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "adminchat", description = "Talk privately with other admins", usage = "/<command> <message>", aliases = "o,ac,sc,staffchat")
public class AdminChatCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(greedyString("message")
.executes(context -> executeCommand(context, argsWithGreedy(string(context, "message")))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -58,9 +66,4 @@ public class AdminChatCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/AdminworldCMD.java
+8 -7
View File
@@ -1,13 +1,13 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.Location;
@@ -20,6 +20,12 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "adminworld", aliases = "aw", description = "Teleport to the adminworld")
public class AdminworldCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -34,9 +40,4 @@ public class AdminworldCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/AdventureCMD.java
+12 -11
View File
@@ -1,6 +1,6 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -9,8 +9,8 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.event.GameModeUpdateEvent;
import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
@@ -23,6 +23,16 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "adventure", aliases = "gma,egma,eadventure,adventuremode,eadventuremode", description = "Set your own or another player's gamemode to adventure mode")
public class AdventureCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(word("target")
.requires(source -> silentCheckPermission(source.getSender(), "plex.gamemode.adventure.others"))
.suggests(suggestPlayersAndAll("plex.gamemode.adventure.others"))
.executes(context -> executeCommand(context, string(context, "target"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -53,13 +63,4 @@ public class AdventureCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (silentCheckPermission(sender, "plex.gamemode.adventure.others"))
{
return PlexUtils.getPlayerNameList();
}
return ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/BanCMD.java
+14 -15
View File
@@ -1,6 +1,7 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -16,9 +17,9 @@ import dev.plex.util.TimeUtils;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.Bukkit;
@@ -27,11 +28,22 @@ import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "ban", usage = "/<command> <player> [reason] [-rb]", aliases = "offlineban,gtfo", description = "Bans a player, offline or online")
@CommandParameters(name = "ban", usage = "/<command> <player> [message] [-rb]", aliases = "offlineban,gtfo", description = "Bans a player, offline or online")
@CommandPermissions(permission = "plex.ban", source = RequiredCommandSource.ANY)
public class BanCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.executes(context -> executeCommand(context, string(context, "player")))
.then(greedyString("message")
.suggests((context, builder) -> suggestOptionalFlags(builder, List.of("-rb")))
.executes(context -> executeCommand(context, argsWithGreedy(string(context, "player"), string(context, "message"))))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -102,17 +114,4 @@ public class BanCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (args.length == 1 && silentCheckPermission(sender, this.getPermission()))
{
return PlexUtils.getPlayerNameList();
}
if (args.length > 1 && silentCheckPermission(sender, this.getPermission()))
{
return Collections.singletonList("-rb");
}
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/BanListCommand.java
+12 -7
View File
@@ -1,14 +1,14 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.punishment.Punishment;
import java.util.List;
import java.util.stream.Collectors;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.command.CommandSender;
@@ -20,6 +20,16 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.banlist")
public class BanListCommand extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(literal("purge")
.executes(context -> executeCommand(context, "purge")));
command.then(literal("clear")
.executes(context -> executeCommand(context, "clear")));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
{
@@ -53,9 +63,4 @@ public class BanListCommand extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, "plex.banlist.clear") ? List.of("purge", "clear") : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/BcastLoginMessageCMD.java
+10 -7
View File
@@ -1,7 +1,7 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -11,8 +11,8 @@ import dev.plex.meta.PlayerMeta;
import dev.plex.player.PlexPlayer;
import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -23,6 +23,14 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "bcastloginmessage", usage = "/<command> <player>", description = "Broadcast your login message (for vanish support)", aliases = "bcastlm")
public class BcastLoginMessageCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.executes(context -> executeCommand(context, string(context, "player"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -52,9 +60,4 @@ public class BcastLoginMessageCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/BlockEditCMD.java
+16 -18
View File
@@ -1,16 +1,15 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.listener.impl.BlockListener;
import dev.plex.util.PlexUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
@@ -24,6 +23,20 @@ public class BlockEditCMD extends ServerCommand
{
private final BlockListener bl = new BlockListener();
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(literal("list")
.executes(context -> executeCommand(context, "list")));
command.then(literal("purge")
.executes(context -> executeCommand(context, "purge")));
command.then(literal("all")
.executes(context -> executeCommand(context, "all")));
command.then(playerArgument("player")
.executes(context -> executeCommand(context, string(context, "player"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args)
{
@@ -101,19 +114,4 @@ public class BlockEditCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (silentCheckPermission(sender, this.getPermission()))
{
List<String> options = new ArrayList<>();
if (args.length == 1)
{
options.addAll(Arrays.asList("list", "purge", "all"));
options.addAll(PlexUtils.getPlayerNameList());
return options;
}
}
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/CommandSpyCMD.java
+8 -7
View File
@@ -1,15 +1,15 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.player.PlexPlayer;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -20,6 +20,12 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "commandspy", aliases = "cmdspy", description = "Spy on other player's commands")
public class CommandSpyCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args)
{
@@ -35,9 +41,4 @@ public class CommandSpyCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/ConsoleSayCMD.java
+10 -7
View File
@@ -1,14 +1,14 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.util.PlexUtils;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.command.CommandSender;
@@ -20,6 +20,14 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "consolesay", usage = "/<command> <message>", description = "Displays a message to everyone", aliases = "csay")
public class ConsoleSayCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(greedyString("message")
.executes(context -> executeCommand(context, argsWithGreedy(string(context, "message")))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -32,9 +40,4 @@ public class ConsoleSayCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/CreativeCMD.java
+12 -11
View File
@@ -1,6 +1,6 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -9,8 +9,8 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.event.GameModeUpdateEvent;
import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
@@ -23,6 +23,16 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "creative", aliases = "gmc,egmc,ecreative,eecreative,creativemode,ecreativemode", description = "Set your own or another player's gamemode to creative mode")
public class CreativeCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(word("target")
.requires(source -> silentCheckPermission(source.getSender(), "plex.gamemode.creative.others"))
.suggests(suggestPlayersAndAll("plex.gamemode.creative.others"))
.executes(context -> executeCommand(context, string(context, "target"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -56,13 +66,4 @@ public class CreativeCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (silentCheckPermission(sender, "plex.gamemode.creative.others"))
{
return PlexUtils.getPlayerNameList();
}
return ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/DebugCMD.java
+24 -8
View File
@@ -1,18 +1,18 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import dev.plex.command.PlexCommand;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.menu.impl.MaterialMenu;
import dev.plex.util.GameRuleUtil;
import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.World;
@@ -26,6 +26,22 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.debug")
public class DebugCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(literal("redis-reset")
.then(playerArgument("player")
.executes(context -> executeCommand(context, "redis-reset", string(context, "player")))));
command.then(literal("gamerules")
.executes(context -> executeCommand(context, "gamerules")));
command.then(literal("aliases")
.then(word("command")
.executes(context -> executeCommand(context, "aliases", string(context, "command")))));
command.then(literal("pagination")
.executes(context -> executeCommand(context, "pagination")));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -69,6 +85,11 @@ public class DebugCMD extends ServerCommand
if (args.length == 2)
{
String commandName = args[1];
PlexCommand plexCommand = plugin.getCommandHandler().getCommand(commandName);
if (plexCommand != null)
{
return messageComponent("commandAliases", commandName, Arrays.toString(plexCommand.getAliases().toArray(new String[0])));
}
Command command = plugin.getServer().getCommandMap().getCommand(commandName);
if (command == null)
{
@@ -89,9 +110,4 @@ public class DebugCMD extends ServerCommand
return usage();
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/EntityWipeCMD.java
+25 -21
View File
@@ -1,5 +1,6 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -9,11 +10,11 @@ import dev.plex.util.PlexUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.World;
@@ -28,6 +29,29 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "entitywipe", description = "Remove various server entities that may cause lag, such as dropped items, minecarts, and boats.", usage = "/<command> [entity] [radius]", aliases = "ew,rd")
public class EntityWipeCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(greedyString("entities")
.suggests(suggestGreedyWords(() ->
{
List<String> entities = new ArrayList<>();
for (World world : Bukkit.getWorlds())
{
for (Entity entity : world.getEntities())
{
if (entity.getType() != EntityType.PLAYER)
{
entities.add(entity.getType().name());
}
}
}
return entities;
}))
.executes(context -> executeCommand(context, argsWithGreedy(string(context, "entities")))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args)
{
@@ -112,26 +136,6 @@ public class EntityWipeCMD extends ServerCommand
return null;
}
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (silentCheckPermission(sender, this.getPermission()))
{
List<String> entities = new ArrayList<>();
for (World world : Bukkit.getWorlds())
{
for (Entity entity : world.getEntities())
{
if (entity.getType() != EntityType.PLAYER)
{
entities.add(entity.getType().name());
}
}
}
return entities.stream().toList();
}
return Collections.emptyList();
}
private Integer parseInt(CommandSender sender, String string)
{
try
server/src/main/java/dev/plex/command/impl/FlatlandsCMD.java
+8 -7
View File
@@ -1,13 +1,13 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.Location;
@@ -20,6 +20,12 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "flatlands", description = "Teleport to the flatlands")
public class FlatlandsCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -33,9 +39,4 @@ public class FlatlandsCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/FreezeCMD.java
+10 -7
View File
@@ -1,6 +1,6 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -12,8 +12,8 @@ import dev.plex.util.TimeUtils;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -24,6 +24,14 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.freeze")
public class FreezeCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.executes(context -> executeCommand(context, string(context, "player"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -54,9 +62,4 @@ public class FreezeCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/GamemodeCMD.java
+40 -37
View File
@@ -1,5 +1,6 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -8,10 +9,7 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.event.GameModeUpdateEvent;
import dev.plex.util.PlexUtils;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
@@ -24,7 +22,32 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.gamemode", source = RequiredCommandSource.ANY)
public class GamemodeCMD extends ServerCommand
{
private GameMode gamemode;
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
addMode(command, "survival", "s", "0");
addMode(command, "creative", "c", "1");
addMode(command, "adventure", "a", "2");
addMode(command, "default", "d", "5");
addMode(command, "spectator", "sp", "3", "6");
}
private void addMode(LiteralArgumentBuilder<CommandSourceStack> command, String mode, String... aliases)
{
command.then(modeNode(mode));
for (String alias : aliases)
{
command.then(modeNode(alias));
}
}
private LiteralArgumentBuilder<CommandSourceStack> modeNode(String mode)
{
return literal(mode)
.executes(context -> executeCommand(context, mode))
.then(playerArgument("player")
.executes(context -> executeCommand(context, mode, string(context, "player"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
@@ -37,47 +60,43 @@ public class GamemodeCMD extends ServerCommand
{
case "survival", "s", "0" ->
{
gamemode = GameMode.SURVIVAL;
update(sender, playerSender, GameMode.SURVIVAL);
update(sender, playerSender, args, GameMode.SURVIVAL);
return null;
}
case "creative", "c", "1" ->
{
gamemode = GameMode.CREATIVE;
update(sender, playerSender, GameMode.CREATIVE);
update(sender, playerSender, args, GameMode.CREATIVE);
return null;
}
case "adventure", "a", "2" ->
{
gamemode = GameMode.ADVENTURE;
update(sender, playerSender, GameMode.ADVENTURE);
update(sender, playerSender, args, GameMode.ADVENTURE);
return null;
}
case "default", "d", "5" ->
{
gamemode = plugin.getServer().getDefaultGameMode();
update(sender, playerSender, plugin.getServer().getDefaultGameMode());
update(sender, playerSender, args, plugin.getServer().getDefaultGameMode());
return null;
}
case "spectator", "sp", "3", "6" ->
{
gamemode = GameMode.SPECTATOR;
checkPermission(sender, "plex.gamemode.spectator");
update(sender, playerSender, GameMode.SPECTATOR);
update(sender, playerSender, args, GameMode.SPECTATOR);
return null;
}
}
return usage();
}
private void update(CommandSender sender, Player playerSender, String[] args, GameMode gameMode)
{
if (args.length > 1)
{
checkPermission(sender, "plex.gamemode.others");
Player player = getNonNullPlayer(args[1]);
Bukkit.getServer().getPluginManager().callEvent(new GameModeUpdateEvent(sender, player, gamemode));
Bukkit.getServer().getPluginManager().callEvent(new GameModeUpdateEvent(sender, player, gameMode));
return;
}
return null;
}
private void update(CommandSender sender, Player playerSender, GameMode gameMode)
{
if (isConsole(sender))
{
throw new CommandFailException(PlexUtils.messageString("consoleMustDefinePlayer"));
@@ -88,20 +107,4 @@ public class GamemodeCMD extends ServerCommand
}
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (args.length == 1)
{
return Arrays.asList("creative", "survival", "adventure", "spectator", "default");
}
if (args.length == 2)
{
if (silentCheckPermission(sender, "plex.gamemode.others"))
{
return PlexUtils.getPlayerNameList();
}
}
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/KickCMD.java
+13 -8
View File
@@ -1,7 +1,7 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -16,8 +16,8 @@ import dev.plex.util.TimeUtils;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.Bukkit;
@@ -26,10 +26,20 @@ import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "kick", description = "Kicks a player", usage = "/<command> <player>")
@CommandParameters(name = "kick", description = "Kicks a player", usage = "/<command> <player>", aliases = "ekick")
@CommandPermissions(permission = "plex.kick", source = RequiredCommandSource.ANY)
public class KickCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.executes(context -> executeCommand(context, string(context, "player")))
.then(greedyString("reason")
.executes(context -> executeCommand(context, argsWithGreedy(string(context, "player"), string(context, "reason"))))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -70,9 +80,4 @@ public class KickCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/ListCMD.java
+13 -9
View File
@@ -1,6 +1,7 @@
package dev.plex.command.impl;
import com.google.common.collect.Lists;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -8,9 +9,9 @@ import dev.plex.hook.VaultHook;
import dev.plex.meta.PlayerMeta;
import dev.plex.util.PlexUtils;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.Bukkit;
@@ -23,6 +24,17 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.list")
public class ListCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(literal("-d")
.executes(context -> executeCommand(context, "-d")));
command.then(literal("-v")
.requires(source -> silentCheckPermission(source.getSender(), "plex.list.vanished"))
.executes(context -> executeCommand(context, "-v")));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -67,12 +79,4 @@ public class ListCMD extends ServerCommand
return list;
}
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (args.length == 1 && silentCheckPermission(sender, this.getPermission()))
{
return List.of("-d", "-v");
}
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/LocalSpawnCMD.java
+8 -7
View File
@@ -1,13 +1,13 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -18,6 +18,12 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.localspawn", source = RequiredCommandSource.IN_GAME)
public class LocalSpawnCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -26,9 +32,4 @@ public class LocalSpawnCMD extends ServerCommand
return messageComponent("teleportedToWorldSpawn");
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/LockupCMD.java
+10 -7
View File
@@ -1,14 +1,14 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.player.PlexPlayer;
import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -19,6 +19,14 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.lockup")
public class LockupCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.executes(context -> executeCommand(context, string(context, "player"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -38,9 +46,4 @@ public class LockupCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/MasterbuilderworldCMD.java
+8 -7
View File
@@ -1,13 +1,13 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.Location;
@@ -20,6 +20,12 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "masterbuilderworld", aliases = "mbw", description = "Teleport to the Master Builder world")
public class MasterbuilderworldCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -34,9 +40,4 @@ public class MasterbuilderworldCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/MobLimitCMD.java
+15 -19
View File
@@ -1,5 +1,6 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -7,9 +8,8 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.util.PlexUtils;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.Chunk;
@@ -23,6 +23,19 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.moblimit", source = RequiredCommandSource.ANY)
public class MobLimitCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(literal("on")
.executes(context -> executeCommand(context, "on")));
command.then(literal("off")
.executes(context -> executeCommand(context, "off")));
command.then(literal("setmax")
.then(nonNegativeInteger("limit")
.executes(context -> executeCommand(context, "setmax", String.valueOf(integer(context, "limit"))))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -83,21 +96,4 @@ public class MobLimitCMD extends ServerCommand
}
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (silentCheckPermission(sender, this.getPermission()))
{
if (args.length == 1)
{
return Arrays.asList("on", "off", "setmax");
}
if (args.length == 2 && args[0].equals("setmax"))
{
return Collections.emptyList();
}
return Collections.emptyList();
}
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/MobPurgeCMD.java
+11 -9
View File
@@ -1,5 +1,6 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -9,9 +10,9 @@ import dev.plex.util.PlexUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang3.text.WordUtils;
import org.bukkit.Bukkit;
@@ -30,6 +31,15 @@ public class MobPurgeCMD extends ServerCommand
{
private final List<EntityType> MOB_TYPES = new ArrayList<>();
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(word("mob")
.suggests(suggest(this::getAllMobs))
.executes(context -> executeCommand(context, string(context, "mob"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args)
{
@@ -112,12 +122,4 @@ public class MobPurgeCMD extends ServerCommand
return mobs;
}
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (args.length == 1 && silentCheckPermission(sender, this.getPermission()))
{
return getAllMobs();
}
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/MuteCMD.java
+11 -8
View File
@@ -1,6 +1,6 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -12,18 +12,26 @@ import dev.plex.util.TimeUtils;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "mute", description = "Mute a player on the server", usage = "/<command> <player>", aliases = "stfu")
@CommandParameters(name = "mute", description = "Mute a player on the server", usage = "/<command> <player>", aliases = "stfu,emute,silence,esilence")
@CommandPermissions(permission = "plex.mute")
public class MuteCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.executes(context -> executeCommand(context, string(context, "player"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -60,9 +68,4 @@ public class MuteCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/NotesCMD.java
+19 -20
View File
@@ -1,21 +1,20 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.player.PlexPlayer;
import dev.plex.punishment.extra.Note;
import dev.plex.util.PlexUtils;
import dev.plex.util.TimeUtils;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
@@ -28,6 +27,23 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.notes")
public class NotesCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.then(literal("list")
.executes(context -> executeCommand(context, string(context, "player"), "list")))
.then(literal("clear")
.executes(context -> executeCommand(context, string(context, "player"), "clear")))
.then(literal("add")
.then(greedyString("note")
.executes(context -> executeCommand(context, argsWithGreedy(string(context, "player"), "add", string(context, "note"))))))
.then(literal("remove")
.then(nonNegativeInteger("id")
.executes(context -> executeCommand(context, string(context, "player"), "remove", String.valueOf(integer(context, "id")))))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -135,21 +151,4 @@ public class NotesCMD extends ServerCommand
send(sender, noteList.get());
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (silentCheckPermission(sender, this.getPermission()))
{
if (args.length == 1)
{
return PlexUtils.getPlayerNameList();
}
if (args.length == 2)
{
return Arrays.asList("list", "add", "remove", "clear");
}
return Collections.emptyList();
}
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/PlexCMD.java
+20 -16
View File
@@ -1,5 +1,6 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -12,11 +13,10 @@ import dev.plex.util.PlexLog;
import dev.plex.util.PlexUtils;
import dev.plex.util.TimeUtils;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.Bukkit;
@@ -31,6 +31,24 @@ import org.jetbrains.annotations.Nullable;
public class PlexCMD extends ServerCommand
{
// Don't modify this command
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(literal("reload")
.executes(context -> executeCommand(context, "reload")));
command.then(literal("redis")
.executes(context -> executeCommand(context, "redis")));
command.then(literal("update")
.executes(context -> executeCommand(context, "update")));
command.then(literal("modules")
.executes(context -> executeCommand(context, "modules"))
.then(literal("reload")
.executes(context -> executeCommand(context, "modules", "reload")))
.then(literal("update")
.executes(context -> executeCommand(context, "modules", "update"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -127,20 +145,6 @@ public class PlexCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (args.length == 1)
{
return Arrays.asList("reload", "redis", "modules", "update");
}
else if (args[0].equalsIgnoreCase("modules"))
{
return Arrays.asList("reload", "update");
}
return Collections.emptyList();
}
// Owners and developers only have access
private boolean hasUpdateAccess(Player player, CommandSender sender)
{
server/src/main/java/dev/plex/command/impl/PunishmentsCMD.java
+10 -8
View File
@@ -1,7 +1,7 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -10,10 +10,9 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.menu.impl.PunishedPlayerMenu;
import dev.plex.menu.impl.PunishmentMenu;
import dev.plex.player.PlexPlayer;
import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
@@ -26,6 +25,14 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.punishments", source = RequiredCommandSource.IN_GAME)
public class PunishmentsCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.executes(context -> executeCommand(context, string(context, "player"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -49,9 +56,4 @@ public class PunishmentsCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/RawSayCMD.java
+10 -7
View File
@@ -1,14 +1,14 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.util.PlexUtils;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.command.CommandSender;
@@ -20,6 +20,14 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "rawsay", usage = "/<command> <message>", description = "Displays a raw message to everyone")
public class RawSayCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(greedyString("message")
.executes(context -> executeCommand(context, argsWithGreedy(string(context, "message")))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -32,9 +40,4 @@ public class RawSayCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/RemoveLoginMessageCMD.java
+13 -15
View File
@@ -1,16 +1,15 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.player.PlexPlayer;
import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -21,6 +20,17 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "removeloginmessage", usage = "/<command> [-o <player>]", description = "Remove your own (or someone else's) login message", aliases = "rlm,removeloginmsg")
public class RemoveLoginMessageCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(literal("-o")
.requires(source -> silentCheckPermission(source.getSender(), "plex.removeloginmessage.others"))
.executes(context -> executeCommand(context, "-o"))
.then(playerArgument("player")
.executes(context -> executeCommand(context, "-o", string(context, "player")))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -57,16 +67,4 @@ public class RemoveLoginMessageCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (args.length == 1)
{
if (silentCheckPermission(sender, "plex.removeloginmessage.others"))
{
return List.of("-o");
}
}
return args.length == 2 && silentCheckPermission(sender, "plex.removeloginmessage.others") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/SayCMD.java
+10 -7
View File
@@ -1,14 +1,14 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.util.PlexUtils;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.command.CommandSender;
@@ -20,6 +20,14 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "say", usage = "/<command> <message>", description = "Displays a message to everyone")
public class SayCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(greedyString("message")
.executes(context -> executeCommand(context, argsWithGreedy(string(context, "message")))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -32,9 +40,4 @@ public class SayCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/SetLoginMessageCMD.java
+34 -13
View File
@@ -1,7 +1,7 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -13,6 +13,7 @@ import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.apache.commons.lang3.StringUtils;
@@ -27,6 +28,38 @@ public class SetLoginMessageCMD extends ServerCommand
{
private final boolean nameRequired = plugin.getConfig().getBoolean("loginmessages.name");
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(greedyString("message")
.suggests((context, builder) ->
{
if (!silentCheckPermission(context.getSource().getSender(), "plex.setloginmessage.others"))
{
return builder.buildFuture();
}
String remaining = builder.getRemaining();
if (remaining.isBlank())
{
return builder.buildFuture();
}
String[] tokens = remaining.split("\\s+", -1);
if (tokens.length == 1 && tokens[0].startsWith("-"))
{
return suggestMatching(builder, List.of("-o"));
}
if (tokens.length == 2 && tokens[0].equalsIgnoreCase("-o"))
{
return suggestLastGreedyToken(builder, PlexUtils.getPlayerNameList());
}
return builder.buildFuture();
})
.executes(context -> executeCommand(context, argsWithGreedy(string(context, "message")))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -83,16 +116,4 @@ public class SetLoginMessageCMD extends ServerCommand
}
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (args.length == 1)
{
if (silentCheckPermission(sender, "plex.setloginmessage"))
{
return List.of("-o");
}
}
return args.length == 2 && args[0].equalsIgnoreCase("-o") && silentCheckPermission(sender, "plex.setloginmessage") ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/SmiteCMD.java
+25 -22
View File
@@ -1,5 +1,6 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -12,12 +13,12 @@ import dev.plex.util.TimeUtils;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Collections;
import java.util.ArrayList;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.title.Title;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.GameMode;
import org.bukkit.Location;
@@ -31,6 +32,17 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "smite", usage = "/<command> <player> [reason] [-ci | -q]", description = "Someone being a little bitch? Smite them down...")
public class SmiteCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.executes(context -> executeCommand(context, string(context, "player")))
.then(greedyString("reason")
.suggests((context, builder) -> suggestOptionalFlags(builder, List.of("-ci", "-q")))
.executes(context -> executeCommand(context, argsWithGreedy(string(context, "player"), string(context, "reason"))))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -45,25 +57,25 @@ public class SmiteCMD extends ServerCommand
if (args.length >= 2)
{
if (args[args.length - 1].equalsIgnoreCase("-q"))
List<String> reasonParts = new ArrayList<>();
for (int i = 1; i < args.length; i++)
{
if (args[i].equalsIgnoreCase("-q"))
{
silent = true;
if (args.length >= 3)
{
reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length - 1), " ");
continue;
}
}
else if (args[args.length - 1].equalsIgnoreCase("-ci"))
if (args[i].equalsIgnoreCase("-ci"))
{
clearInv = true;
if (args.length >= 3)
{
reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length - 1), " ");
continue;
}
reasonParts.add(args[i]);
}
else
if (!reasonParts.isEmpty())
{
reason = StringUtils.join(ArrayUtils.subarray(args, 1, args.length), " ");
reason = StringUtils.join(reasonParts, " ");
}
}
@@ -121,13 +133,4 @@ public class SmiteCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (silentCheckPermission(sender, this.getPermission()) && args.length == 1)
{
return PlexUtils.getPlayerNameList();
}
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/SpectatorCMD.java
+12 -11
View File
@@ -1,6 +1,6 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -9,8 +9,8 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.event.GameModeUpdateEvent;
import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
@@ -23,6 +23,16 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "spectator", aliases = "gmsp,egmsp,spec", description = "Set your own or another player's gamemode to spectator mode")
public class SpectatorCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(word("target")
.requires(source -> silentCheckPermission(source.getSender(), "plex.gamemode.spectator.others"))
.suggests(suggestPlayersAndAll("plex.gamemode.spectator.others"))
.executes(context -> executeCommand(context, string(context, "target"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -55,13 +65,4 @@ public class SpectatorCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (silentCheckPermission(sender, "plex.gamemode.spectator.others"))
{
return PlexUtils.getPlayerNameList();
}
return ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/SurvivalCMD.java
+12 -11
View File
@@ -1,6 +1,6 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -9,8 +9,8 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.event.GameModeUpdateEvent;
import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
@@ -23,6 +23,16 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "survival", aliases = "gms,egms,esurvival,survivalmode,esurvivalmode", description = "Set your own or another player's gamemode to survival mode")
public class SurvivalCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(word("target")
.requires(source -> silentCheckPermission(source.getSender(), "plex.gamemode.survival.others"))
.suggests(suggestPlayersAndAll("plex.gamemode.survival.others"))
.executes(context -> executeCommand(context, string(context, "target"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -56,13 +66,4 @@ public class SurvivalCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (silentCheckPermission(sender, "plex.gamemode.survival.others"))
{
return PlexUtils.getPlayerNameList();
}
return ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/TagCMD.java
+16 -22
View File
@@ -1,6 +1,7 @@
package dev.plex.command.impl;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -8,10 +9,8 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.player.PlexPlayer;
import dev.plex.util.PlexUtils;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
@@ -26,6 +25,20 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "tag", aliases = "prefix", description = "Set or clear your prefix", usage = "/<command> <set <prefix> | clear <player>>")
public class TagCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(literal("set")
.executes(context -> executeCommand(context, "set"))
.then(greedyString("prefix")
.executes(context -> executeCommand(context, argsWithGreedy("set", string(context, "prefix"))))));
command.then(literal("clear")
.executes(context -> executeCommand(context, "clear"))
.then(playerArgument("player")
.executes(context -> executeCommand(context, "clear", string(context, "player")))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -92,25 +105,6 @@ public class TagCMD extends ServerCommand
return usage();
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (args.length == 1)
{
return Arrays.asList("set", "clear");
}
if (args.length == 2)
{
if (args[0].equalsIgnoreCase("clear"))
{
if (silentCheckPermission(sender, "plex.tag.clear.others"))
{
return PlexUtils.getPlayerNameList();
}
}
}
return Collections.emptyList();
}
}
server/src/main/java/dev/plex/command/impl/TempbanCMD.java
+16 -8
View File
@@ -1,7 +1,7 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -16,6 +16,7 @@ import dev.plex.util.TimeUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.Bukkit;
@@ -24,11 +25,23 @@ import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "tempban", usage = "/<command> <player> <time> [reason] [-rb]", description = "Temporarily ban a player")
@CommandParameters(name = "tempban", usage = "/<command> <player> <time> [message] [-rb]", description = "Temporarily ban a player")
@CommandPermissions(permission = "plex.tempban", source = RequiredCommandSource.ANY)
public class TempbanCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.then(word("time")
.executes(context -> executeCommand(context, string(context, "player"), string(context, "time")))
.then(greedyString("message")
.suggests((context, builder) -> suggestOptionalFlags(builder, List.of("-rb")))
.executes(context -> executeCommand(context, argsWithGreedy(string(context, "player"), string(context, "time"), string(context, "message")))))));
}
@Override
public Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -56,7 +69,7 @@ public class TempbanCMD extends ServerCommand
if (args.length > 2)
{
reason = StringUtils.join(args, " ", 2, args.length);
String newReason = StringUtils.normalizeSpace(reason.replace("-nrb", ""));
String newReason = StringUtils.normalizeSpace(reason.replace("-rb", ""));
punishment.setReason(newReason.trim().isEmpty() ? messageString("noReasonProvided") : newReason);
rollBack = reason.startsWith("-rb") || reason.endsWith("-rb");
}
@@ -82,9 +95,4 @@ public class TempbanCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/TempmuteCMD.java
+13 -7
View File
@@ -1,6 +1,6 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -12,8 +12,8 @@ import dev.plex.util.TimeUtils;
import java.time.ZonedDateTime;
import java.util.Arrays;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -25,6 +25,17 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.tempmute")
public class TempmuteCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.then(word("time")
.executes(context -> executeCommand(context, string(context, "player"), string(context, "time")))
.then(greedyString("reason")
.executes(context -> executeCommand(context, argsWithGreedy(string(context, "player"), string(context, "time"), string(context, "reason")))))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -85,9 +96,4 @@ public class TempmuteCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/ToggleCMD.java
+20 -8
View File
@@ -1,6 +1,6 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -8,8 +8,8 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.menu.impl.ToggleMenu;
import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -20,6 +20,24 @@ import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.toggle", source = RequiredCommandSource.ANY)
public class ToggleCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(literal("explosions")
.executes(context -> executeCommand(context, "explosions")));
command.then(literal("fluidspread")
.executes(context -> executeCommand(context, "fluidspread")));
command.then(literal("drops")
.executes(context -> executeCommand(context, "drops")));
command.then(literal("redstone")
.executes(context -> executeCommand(context, "redstone")));
command.then(literal("pvp")
.executes(context -> executeCommand(context, "pvp")));
command.then(literal("chat")
.executes(context -> executeCommand(context, "chat")));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -73,12 +91,6 @@ public class ToggleCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
private Component toggleListItem(String nameKey, String toggle)
{
return messageComponent("toggleListItem", messageString(nameKey), status(toggle));
server/src/main/java/dev/plex/command/impl/UnbanCMD.java
+10 -7
View File
@@ -1,7 +1,7 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -10,8 +10,8 @@ import dev.plex.command.source.RequiredCommandSource;
import dev.plex.player.PlexPlayer;
import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -23,6 +23,14 @@ import org.jetbrains.annotations.Nullable;
public class UnbanCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.executes(context -> executeCommand(context, string(context, "player"))));
}
@Override
public Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -54,9 +62,4 @@ public class UnbanCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/UnfreezeCMD.java
+10 -7
View File
@@ -1,7 +1,7 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -11,8 +11,8 @@ import dev.plex.player.PlexPlayer;
import dev.plex.punishment.PunishmentType;
import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -23,6 +23,14 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "unfreeze", description = "Unfreeze a player", usage = "/<command> <player>")
public class UnfreezeCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.executes(context -> executeCommand(context, string(context, "player"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -50,9 +58,4 @@ public class UnfreezeCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/UnmuteCMD.java
+11 -8
View File
@@ -1,7 +1,7 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -11,8 +11,8 @@ import dev.plex.player.PlexPlayer;
import dev.plex.punishment.PunishmentType;
import dev.plex.util.PlexUtils;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@@ -20,9 +20,17 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@CommandPermissions(permission = "plex.unmute")
@CommandParameters(name = "unmute", description = "Unmute a player", usage = "/<command> <player>")
@CommandParameters(name = "unmute", description = "Unmute a player", usage = "/<command> <player>", aliases = "eunmute")
public class UnmuteCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(playerArgument("player")
.executes(context -> executeCommand(context, string(context, "player"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -50,9 +58,4 @@ public class UnmuteCMD extends ServerCommand
return null;
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
return args.length == 1 && silentCheckPermission(sender, this.getPermission()) ? PlexUtils.getPlayerNameList() : ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/WhoHasCMD.java
+13 -15
View File
@@ -1,14 +1,14 @@
package dev.plex.command.impl;
import com.google.common.collect.ImmutableList;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.JoinConfiguration;
import net.kyori.adventure.text.TextComponent;
@@ -23,6 +23,17 @@ import org.jetbrains.annotations.Nullable;
@CommandParameters(name = "whohas", description = "Returns a list of players with a specific item in their inventory.", usage = "/<command> <material>", aliases = "wh")
public class WhoHasCMD extends ServerCommand
{
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(word("material")
.suggests(suggest(() -> Arrays.stream(Material.values()).map(Enum::name).toList()))
.executes(context -> executeCommand(context, string(context, "material")))
.then(literal("clear")
.executes(context -> executeCommand(context, string(context, "material"), "clear"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, @NotNull String[] args)
{
@@ -65,17 +76,4 @@ public class WhoHasCMD extends ServerCommand
Component.join(JoinConfiguration.commas(true), players)));
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
if (args.length == 1 && silentCheckPermission(sender, this.getPermission()))
{
return Arrays.stream(Material.values()).map(Enum::name).toList();
}
else if (args.length == 2 && silentCheckPermission(sender, "plex.whohas.clear"))
{
return Collections.singletonList("clear");
}
return ImmutableList.of();
}
}
server/src/main/java/dev/plex/command/impl/WorldCMD.java
+35 -29
View File
@@ -1,6 +1,7 @@
package dev.plex.command.impl;
import com.google.common.collect.Lists;
import com.mojang.brigadier.builder.LiteralArgumentBuilder;
import dev.plex.command.ServerCommand;
import dev.plex.command.annotation.CommandParameters;
import dev.plex.command.annotation.CommandPermissions;
@@ -10,6 +11,7 @@ import java.util.List;
import java.util.UUID;
import java.util.regex.Pattern;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.World;
@@ -24,6 +26,39 @@ public class WorldCMD extends ServerCommand
{
private static final Pattern UUID_PATTERN = Pattern.compile("[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}");
@Override
protected void buildCommand(LiteralArgumentBuilder<CommandSourceStack> command)
{
command.executes(context -> executeCommand(context));
command.then(word("world")
.suggests((context, builder) ->
{
if (!(context.getSource().getSender() instanceof Player player))
{
return builder.buildFuture();
}
List<String> completions = Lists.newArrayList();
for (World world : Bukkit.getWorlds())
{
String worldName = world.getName();
try
{
UUID uuid = UUID.fromString(worldName);
if (uuid.equals(player.getUniqueId()) || silentCheckPermission(player, "plex.world.playerworlds"))
{
completions.add(worldName);
}
}
catch (Exception e)
{
completions.add(worldName);
}
}
return suggestMatching(builder, completions);
})
.executes(context -> executeCommand(context, string(context, "world"))));
}
@Override
protected Component execute(@NotNull CommandSender sender, @Nullable Player playerSender, String[] args)
{
@@ -43,33 +78,4 @@ public class WorldCMD extends ServerCommand
return messageComponent("playerWorldTeleport", world.getName());
}
@Override
public @NotNull List<String> smartTabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
{
final List<String> completions = Lists.newArrayList();
final Player player = (Player) sender;
if (args.length == 1 && silentCheckPermission(sender, this.getPermission()))
{
@NotNull List<World> worlds = Bukkit.getWorlds();
for (World world : worlds)
{
String worldName = world.getName();
try
{
final UUID uuid = UUID.fromString(worldName);
if (uuid.equals(player.getUniqueId()) || silentCheckPermission(player, "plex.world.playerworlds"))
{
completions.add(worldName);
}
}
catch (Exception e)
{
completions.add(worldName);
}
}
}
return completions;
}
}
server/src/main/java/dev/plex/handlers/CommandHandler.java
+111 -25
View File
@@ -1,45 +1,131 @@
package dev.plex.handlers;
import com.google.common.collect.Lists;
import dev.plex.Plex;
import dev.plex.command.ServerCommand;
import dev.plex.command.impl.DebugCMD;
import dev.plex.command.PlexCommand;
import dev.plex.command.impl.*;
import dev.plex.util.PlexLog;
import dev.plex.util.ReflectionsUtil;
import java.lang.reflect.InvocationTargetException;
import io.papermc.paper.command.brigadier.Commands;
import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.Locale;
import org.jetbrains.annotations.Nullable;
public class CommandHandler
{
private final Plex plugin;
private final List<PlexCommand> commands = new ArrayList<>();
private boolean lifecycleRegistered;
public CommandHandler(Plex plugin)
{
this.plugin = plugin;
Set<Class<? extends ServerCommand>> commandSet = ReflectionsUtil.getClassesBySubType("dev.plex.command.impl", ServerCommand.class);
List<ServerCommand> commands = Lists.newArrayList();
registerBuiltInCommands(plugin.config.getBoolean("debug"));
commands.addAll(plugin.getPendingCommands());
plugin.getPendingCommands().clear();
plugin.getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS, event -> register(event.registrar()));
}
commandSet.forEach(clazz ->
public void registerCommand(PlexCommand command)
{
try
commands.add(command);
if (lifecycleRegistered)
{
if (plugin.config.getBoolean("debug") && DebugCMD.class.isAssignableFrom(clazz))
{
commands.add(clazz.getConstructor().newInstance());
}
else
{
commands.add(clazz.getConstructor().newInstance());
PlexLog.warn("Command {0} was registered after the Brigadier command lifecycle event; it will be included on the next command reload.", command.getName());
}
}
catch (InvocationTargetException | InstantiationException | IllegalAccessException |
NoSuchMethodException ex)
public void unregisterCommand(PlexCommand command)
{
PlexLog.error("Failed to register " + clazz.getSimpleName() + " as a command!");
commands.remove(command);
}
public @Nullable PlexCommand getCommand(String name)
{
String normalized = name.toLowerCase(Locale.ROOT);
return commands.stream()
.filter(command -> command.getName().equalsIgnoreCase(name) ||
command.getAliases().stream().map(alias -> alias.toLowerCase(Locale.ROOT)).toList().contains(normalized))
.findFirst()
.orElse(null);
}
public boolean isAliasFor(String commandName, String alias)
{
PlexCommand command = getCommand(commandName);
if (command == null)
{
return false;
}
String normalized = alias.toLowerCase(Locale.ROOT);
return command.getAliases().stream().map(value -> value.toLowerCase(Locale.ROOT)).toList().contains(normalized);
}
private void register(Commands registrar)
{
int labels = 0;
for (PlexCommand command : commands)
{
var registeredLabels = registrar.register(command.buildCommand(), command.getDescription(), command.getAliases());
labels += registeredLabels.size();
for (String alias : command.getAliases())
{
if (!registeredLabels.contains(alias) && !registeredLabels.contains("plex:" + alias))
{
PlexLog.warn("Command alias {0} for {1} was not registered, likely because another command already owns it.", alias, command.getName());
}
}
}
lifecycleRegistered = true;
PlexLog.log("Registered {0} Brigadier commands with {1} root labels.", commands.size(), labels);
}
private void registerBuiltInCommands(boolean debugEnabled)
{
commands.addAll(List.of(
new AdminChatCMD(),
new AdminworldCMD(),
new AdventureCMD(),
new BanCMD(),
new BanListCommand(),
new BcastLoginMessageCMD(),
new BlockEditCMD(),
new CommandSpyCMD(),
new ConsoleSayCMD(),
new CreativeCMD(),
new EntityWipeCMD(),
new FlatlandsCMD(),
new FreezeCMD(),
new GamemodeCMD(),
new KickCMD(),
new ListCMD(),
new LocalSpawnCMD(),
new LockupCMD(),
new MasterbuilderworldCMD(),
new MobLimitCMD(),
new MobPurgeCMD(),
new MuteCMD(),
new NotesCMD(),
new PlexCMD(),
new PunishmentsCMD(),
new RawSayCMD(),
new RemoveLoginMessageCMD(),
new SayCMD(),
new SetLoginMessageCMD(),
new SmiteCMD(),
new SpectatorCMD(),
new SurvivalCMD(),
new TagCMD(),
new TempbanCMD(),
new TempmuteCMD(),
new ToggleCMD(),
new UnbanCMD(),
new UnfreezeCMD(),
new UnmuteCMD(),
new WhoHasCMD(),
new WorldCMD()
));
if (debugEnabled)
{
commands.add(new DebugCMD());
}
});
PlexLog.log(String.format("Registered %s commands from %s classes!", commands.size(), commandSet.size()));
}
}
server/src/main/java/dev/plex/listener/impl/MuteListener.java
+7
View File
@@ -48,6 +48,13 @@ public class MuteListener extends ServerListenerBase
for (String command : commands)
{
if (plugin.getCommandHandler() != null && plugin.getCommandHandler().isAliasFor(command, message))
{
PlexLog.debug("Matches Brigadier alias");
event.getPlayer().sendMessage(PlexUtils.messageComponent("muted"));
event.setCancelled(true);
return;
}
Command cmd = Bukkit.getCommandMap().getCommand(command);
if (cmd == null)
{
server/src/main/java/dev/plex/listener/impl/TogglesListener.java
+6
View File
@@ -103,6 +103,12 @@ public class TogglesListener extends ServerListenerBase
for (String command : commands)
{
if (plugin.getCommandHandler() != null && plugin.getCommandHandler().isAliasFor(command, message))
{
event.getPlayer().sendMessage(PlexUtils.messageComponent("chatIsOff"));
event.setCancelled(true);
return;
}
Command cmd = Bukkit.getCommandMap().getCommand(command);
if (cmd == null)
{
server/src/main/java/dev/plex/module/ModuleManager.java
-11
View File
@@ -154,17 +154,6 @@ public class ModuleManager
module.getCommands().stream().toList().forEach(plexCommand ->
{
module.unregisterCommand(plexCommand);
plugin.getServer().getCommandMap().getKnownCommands().remove(plexCommand.getName());
plexCommand.unregister(plugin.getServer().getCommandMap());
try
{
plugin.getServer().getCommandMap().getCommand(plexCommand.getName()).unregister(plugin.getServer().getCommandMap());
}
catch (Exception ignored)
{
}
plexCommand.getAliases().forEach(alias -> plugin.getServer().getCommandMap().getKnownCommands().remove(alias));
});
module.getListeners().stream().toList().forEach(module::unregisterListener);
module.disable();