Plex/src/main/java/dev/plex/command/PlexCommand.java

510 lines
15 KiB
Java
Raw Normal View History

2021-01-03 07:21:15 +00:00
package dev.plex.command;
2020-10-31 04:51:22 +00:00
2021-01-03 07:21:15 +00:00
import dev.plex.Plex;
2022-01-04 03:04:39 +00:00
import dev.plex.cache.DataUtils;
import dev.plex.cache.PlayerCache;
2021-01-03 07:21:15 +00:00
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;
2021-01-03 07:21:15 +00:00
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.player.PlexPlayer;
import dev.plex.rank.enums.Rank;
2022-01-29 22:35:48 +00:00
import dev.plex.util.PlexLog;
2021-01-03 07:21:15 +00:00
import dev.plex.util.PlexUtils;
import java.util.Arrays;
import java.util.UUID;
import net.kyori.adventure.audience.Audience;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
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.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
2020-10-31 04:51:22 +00:00
/**
* Superclass for all commands
*/
public abstract class PlexCommand extends Command implements PluginIdentifiableCommand
2020-10-31 04:51:22 +00:00
{
/**
* Returns the instance of the plugin
*/
protected static Plex plugin = Plex.get();
/**
* The parameters for the command
*/
2020-10-31 04:51:22 +00:00
private final CommandParameters params;
/**
* The permissions for the command
*/
2020-10-31 04:51:22 +00:00
private final CommandPermissions perms;
/**
* Minimum required rank fetched from the permissions
*/
2020-10-31 04:51:22 +00:00
private final Rank level;
/**
* Required command source fetched from the permissions
*/
private final RequiredCommandSource commandSource;
2020-10-31 04:51:22 +00:00
/**
* Creates an instance of the command
*/
public PlexCommand()
2020-10-31 04:51:22 +00:00
{
super("");
this.params = getClass().getAnnotation(CommandParameters.class);
this.perms = getClass().getAnnotation(CommandPermissions.class);
setName(this.params.name());
setLabel(this.params.name());
setDescription(params.description());
setUsage(params.usage().replace("<command>", this.params.name()));
if (params.aliases().split(",").length > 0)
{
setAliases(Arrays.asList(params.aliases().split(",")));
}
this.level = perms.level();
this.commandSource = perms.source();
2022-01-04 03:04:39 +00:00
getMap().register("plex", this);
2020-10-31 04:51:22 +00:00
}
/**
* Executes the command
2022-02-07 05:58:55 +00:00
*
* @param sender The sender of the command
* @param playerSender The player who executed the command (null if command source is console or if command source is any but console executed)
2022-02-07 05:58:55 +00:00
* @param args A Kyori Component to send to the sender (can be null)
* @return
*/
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)
2020-10-31 04:51:22 +00:00
{
2020-11-06 01:29:38 +00:00
if (!matches(label))
{
return false;
}
if (commandSource == RequiredCommandSource.CONSOLE && sender instanceof Player)
{
2020-11-05 21:17:14 +00:00
sender.sendMessage(tl("noPermissionInGame"));
return true;
}
if (commandSource == RequiredCommandSource.IN_GAME)
2020-10-31 04:51:22 +00:00
{
if (sender instanceof ConsoleCommandSender)
{
send(sender, tl("noPermissionConsole"));
return true;
}
}
if (sender instanceof Player player)
{
PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId());
2022-01-29 22:35:48 +00:00
2022-02-01 06:31:06 +00:00
if (plugin.getSystem().equalsIgnoreCase("ranks"))
2022-01-29 22:35:48 +00:00
{
if (!plexPlayer.getRankFromString().isAtLeast(getLevel()))
{
send(sender, tl("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMessage())));
return true;
2022-01-29 22:35:48 +00:00
}
2022-02-07 05:58:55 +00:00
}
else if (plugin.getSystem().equalsIgnoreCase("permissions"))
2022-01-29 22:35:48 +00:00
{
if (!player.hasPermission(perms.permission()))
{
send(sender, tl("noPermissionNode", perms.permission()));
return true;
2022-01-29 22:35:48 +00:00
}
2022-02-07 05:58:55 +00:00
}
else
2020-10-31 04:51:22 +00:00
{
2022-01-29 22:35:48 +00:00
PlexLog.error("Neither permissions or ranks were selected to be used in the configuration file!");
send(sender, "There is a server misconfiguration. Please alert a developer or the owner");
return true;
2020-10-31 04:51:22 +00:00
}
}
try
{
2022-02-07 05:58:55 +00:00
Component component = this.execute(sender, isConsole(sender) ? null : (Player)sender, args);
if (component != null)
{
send(sender, component);
}
}
catch (PlayerNotFoundException | CommandFailException
2022-01-30 01:53:22 +00:00
| ConsoleOnlyException | ConsoleMustDefinePlayerException
| PlayerNotBannedException ex)
{
send(sender, ex.getMessage());
}
return true;
2020-10-31 04:51:22 +00:00
}
/**
* Checks if the string given is a command string
2022-02-07 05:58:55 +00:00
*
* @param label The string to check
* @return true if the string is a command name or alias
*/
private boolean matches(String label)
{
if (params.aliases().split(",").length > 0)
2020-10-31 04:51:22 +00:00
{
for (String alias : params.aliases().split(","))
{
if (alias.equalsIgnoreCase(label) || getName().equalsIgnoreCase(label))
{
return true;
}
}
2022-02-07 05:58:55 +00:00
}
else if (params.aliases().split(",").length < 1)
2020-10-31 04:51:22 +00:00
{
return getName().equalsIgnoreCase(label);
2020-10-31 04:51:22 +00:00
}
return false;
2020-10-31 04:51:22 +00:00
}
/**
* Gets a PlexPlayer from Player object
2022-02-07 05:58:55 +00:00
*
* @param player The player object
2022-02-07 05:58:55 +00:00
* @return PlexPlayer Object
* @see PlexPlayer
*/
protected PlexPlayer getPlexPlayer(@NotNull Player player)
{
return DataUtils.getPlayer(player.getUniqueId());
}
/**
* Sends a message to an audience
2022-02-07 05:58:55 +00:00
*
* @param audience The audience to send the message to
2022-02-07 05:58:55 +00:00
* @param s The message to send
*/
protected void send(Audience audience, String s)
{
audience.sendMessage(componentFromString(s));
}
/**
* Sends a message to an audience
2022-02-07 05:58:55 +00:00
*
* @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
2022-02-07 05:58:55 +00:00
*
* @param sender A command sender
* @param rank The rank to check (if the server is using ranks)
* @param permission The permission to check (if the server is using permissions)
* @return true if the sender has enough permissions
* @see Rank
*/
protected boolean checkRank(CommandSender sender, Rank rank, String permission)
{
if (!isConsole(sender))
{
2022-02-07 05:58:55 +00:00
return checkRank((Player)sender, rank, permission);
}
return true;
}
/**
* Checks whether a player has enough permissions or is high enough a rank
2022-02-07 05:58:55 +00:00
*
* @param player The player object
* @param rank The rank to check (if the server is using ranks)
* @param permission The permission to check (if the server is using permissions)
* @return true if the sender has enough permissions
* @see Rank
*/
2022-01-30 00:43:44 +00:00
protected boolean checkRank(Player player, Rank rank, String permission)
2022-01-29 22:35:48 +00:00
{
if (player instanceof ConsoleCommandSender)
{
return true;
}
2022-01-29 22:35:48 +00:00
PlexPlayer plexPlayer = getPlexPlayer(player);
2022-02-01 06:31:06 +00:00
if (plugin.getSystem().equalsIgnoreCase("ranks"))
2022-01-29 22:35:48 +00:00
{
2022-02-22 06:55:59 +00:00
if (!plexPlayer.getRankFromString().isAtLeast(rank))
2022-01-30 00:43:44 +00:00
{
throw new CommandFailException(PlexUtils.tl("noPermissionRank", ChatColor.stripColor(rank.getLoginMessage())));
2022-01-30 00:43:44 +00:00
}
2022-02-07 05:58:55 +00:00
}
else if (plugin.getSystem().equalsIgnoreCase("permissions"))
2022-01-29 22:35:48 +00:00
{
if (!player.hasPermission(permission))
{
throw new CommandFailException(PlexUtils.tl("noPermissionNode", permission));
2022-01-29 22:35:48 +00:00
}
}
2022-01-30 00:43:44 +00:00
return true;
2022-01-29 22:35:48 +00:00
}
/**
* Checks whether a sender has enough permissions or is high enough a rank
*
* @param sender The player object
* @param rank The rank to check (if the server is using ranks)
* @param permission The permission to check (if the server is using permissions)
* @return true if the sender has enough permissions
* @see Rank
*/
protected boolean checkTab(CommandSender sender, Rank rank, String permission)
{
if (!isConsole(sender))
{
return checkTab((Player)sender, rank, permission);
}
return true;
}
/**
* Checks whether a player has enough permissions or is high enough a rank
*
* @param player The player object
* @param rank The rank to check (if the server is using ranks)
* @param permission The permission to check (if the server is using permissions)
* @return true if the sender has enough permissions
* @see Rank
*/
protected boolean checkTab(Player player, Rank rank, String permission)
{
PlexPlayer plexPlayer = getPlexPlayer(player);
if (plugin.getSystem().equalsIgnoreCase("ranks"))
{
2022-02-18 02:00:47 +00:00
return plexPlayer.getRankFromString().isAtLeast(rank);
}
else if (plugin.getSystem().equalsIgnoreCase("permissions"))
{
return player.hasPermission(permission);
}
return true;
}
/**
* Checks if a player is an admin
2022-02-07 05:58:55 +00:00
*
* @param plexPlayer The PlexPlayer object
* @return true if the player is an admin
* @see PlexPlayer
*/
protected boolean isAdmin(PlexPlayer plexPlayer)
{
return Plex.get().getRankManager().isAdmin(plexPlayer);
}
/**
* Checks if a sender is an admin
2022-02-07 05:58:55 +00:00
*
* @param sender A command sender
* @return true if the sender is an admin or if console
*/
protected boolean isAdmin(CommandSender sender)
{
if (!(sender instanceof Player player))
{
return true;
}
PlexPlayer plexPlayer = getPlexPlayer(player);
2022-01-29 22:35:48 +00:00
return plugin.getRankManager().isAdmin(plexPlayer);
}
/**
* Checks if a username is an admin
2022-02-07 05:58:55 +00:00
*
* @param name The username
* @return true if the username is an admin
*/
protected boolean isAdmin(String name)
{
PlexPlayer plexPlayer = DataUtils.getPlayer(name);
2022-01-29 22:35:48 +00:00
return plugin.getRankManager().isAdmin(plexPlayer);
}
/**
* Checks if a sender is a senior admin
2022-02-07 05:58:55 +00:00
*
* @param sender A command sender
* @return true if the sender is a senior admin or if console
*/
protected boolean isSeniorAdmin(CommandSender sender)
{
if (!(sender instanceof Player player))
{
return true;
}
PlexPlayer plexPlayer = getPlexPlayer(player);
2022-01-29 22:35:48 +00:00
return plugin.getRankManager().isSeniorAdmin(plexPlayer);
}
/**
* Gets the UUID of the sender
2022-02-07 05:58:55 +00:00
*
* @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))
{
return null;
}
return player.getUniqueId();
}
/**
* The plugin
2022-02-07 05:58:55 +00:00
*
* @return The instance of the plugin
* @see Plex
*/
@Override
public @NotNull Plex getPlugin()
{
return plugin;
}
/**
* Checks whether a sender is console
2022-02-07 05:58:55 +00:00
*
* @param sender A command sender
* @return true if the sender is console
*/
protected boolean isConsole(CommandSender sender)
2020-11-05 21:17:14 +00:00
{
return !(sender instanceof Player);
2020-11-05 21:17:14 +00:00
}
/**
* Converts a message entry from the "messages.yml" to a component
2022-02-07 05:58:55 +00:00
*
* @param s The message entry
* @param objects Any objects to replace in order
* @return A kyori component
*/
protected Component tl(String s, Object... objects)
{
return componentFromString(PlexUtils.tl(s, objects));
}
/**
* Converts usage to a component
2022-02-07 05:58:55 +00:00
*
* @return A Kyori component stating the usage
*/
protected Component usage()
{
return componentFromString(ChatColor.YELLOW + "Correct Usage: " + ChatColor.GRAY + this.getUsage());
}
/**
* Converts usage to a component
*
* s The usage to convert
* @return A Kyori component stating the usage
*/
protected Component usage(String s)
{
return componentFromString(ChatColor.YELLOW + "Correct Usage: " + ChatColor.GRAY + this.getUsage());
}
protected Player getNonNullPlayer(String name)
{
Player player = Bukkit.getPlayer(name);
if (player == null)
2020-11-06 01:29:38 +00:00
{
throw new PlayerNotFoundException();
2020-11-06 01:29:38 +00:00
}
return player;
}
protected PlexPlayer getOnlinePlexPlayer(String name)
{
Player player = getNonNullPlayer(name);
PlexPlayer plexPlayer = PlayerCache.getPlexPlayer(player.getUniqueId());
if (plexPlayer == null)
2020-11-06 01:29:38 +00:00
{
throw new PlayerNotFoundException();
2020-11-06 01:29:38 +00:00
}
return plexPlayer;
}
protected PlexPlayer getOfflinePlexPlayer(UUID uuid)
{
PlexPlayer plexPlayer = DataUtils.getPlayer(uuid);
if (plexPlayer == null)
2020-11-06 01:29:38 +00:00
{
throw new PlayerNotFoundException();
2020-11-06 01:29:38 +00:00
}
return plexPlayer;
}
protected World getNonNullWorld(String name)
{
World world = Bukkit.getWorld(name);
if (world == null)
2020-11-06 01:29:38 +00:00
{
throw new CommandFailException(PlexUtils.tl("worldNotFound"));
2020-11-06 01:29:38 +00:00
}
return world;
}
/**
* Converts a string to a legacy kyori component
2022-02-07 05:58:55 +00:00
*
* @param s The string to convert
* @return A kyori component
*/
protected Component componentFromString(String s)
{
return LegacyComponentSerializer.legacyAmpersand().deserialize(s);
}
public Rank getLevel()
2020-10-31 04:51:22 +00:00
{
return level;
}
public CommandMap getMap()
{
return Plex.get().getServer().getCommandMap();
2020-10-31 04:51:22 +00:00
}
}