Plexus/Plex
1
0
Fork 0
mirror of https://github.com/plexusorg/Plex.git synced 2025-07-04 16:56:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Migrate (what I could find) legacy component system uses to kyori component system

Browse Source 
Create List command
Remove fionn command
Remove test command
Add Mojang Utils
Auto add Plex Players back to cache on start if any are online
This commit is contained in:
spacerocket62
2022-01-27 01:00:50 -08:00
parent 29b547fc8b
commit 8202021f07
28 changed files with 510 additions and 573 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
src/main/java/dev/plex/command/PlexCommand.java
View File

@ -11,22 +11,25 @@ import dev.plex.command.exception.CommandFailException;
import dev.plex.command.exception.ConsoleMustDefinePlayerException;
import dev.plex.command.exception.ConsoleOnlyException;
import dev.plex.command.exception.PlayerNotFoundException;
import dev.plex.command.source.CommandSource;
import dev.plex.command.source.RequiredCommandSource;
import dev.plex.player.PlexPlayer;
import dev.plex.rank.enums.Rank;
import dev.plex.util.PlexUtils;
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.*;
import org.bukkit.entity.Player;
import org.jetbrains.annotations.NotNull;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
public abstract class PlexCommand extends Command implements TabExecutor, IPlexCommand
public abstract class PlexCommand extends Command
{
protected static Plex plugin = Plex.get();
@ -34,19 +37,18 @@ public abstract class PlexCommand extends Command implements TabExecutor, IPlexC
private final CommandPermissions perms;
private final Rank level;
private CommandSource sender;
private final RequiredCommandSource commandSource;
public PlexCommand(String name)
public PlexCommand()
{
super(name);
super("");
this.params = getClass().getAnnotation(CommandParameters.class);
this.perms = getClass().getAnnotation(CommandPermissions.class);
setName(name);
setLabel(name);
setName(this.params.name());
setLabel(this.params.name());
setDescription(params.description());
setUsage(params.usage().replace("<command>", name));
setUsage(params.usage().replace("<command>", this.params.name()));
if (params.aliases().split(",").length > 0)
{
setAliases(Arrays.asList(params.aliases().split(",")));
@ -57,16 +59,11 @@ public abstract class PlexCommand extends Command implements TabExecutor, IPlexC
getMap().register("plex", this);
}
protected abstract Component execute(CommandSender sender, String[] args);
@Override
public boolean execute(CommandSender sender, String label, String[] args)
{
onCommand(sender, this, label, args);
return true;
}
@Override
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args)
public boolean execute(@NotNull CommandSender sender, @NotNull String label, String[] args)
{
if (!matches(label))
{
@ -82,77 +79,45 @@ public abstract class PlexCommand extends Command implements TabExecutor, IPlexC
{
if (sender instanceof ConsoleCommandSender)
{
sender.sendMessage(tl("noPermissionConsole"));
send(sender, tl("noPermissionConsole"));
return true;
}
Player player = (Player)sender;
this.sender = new CommandSource(player);
PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId());
if (!plexPlayer.getRankFromString().isAtLeast(getLevel()))
{
sender.sendMessage(tl("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMSG())));
send(sender, tl("noPermissionRank", ChatColor.stripColor(getLevel().getLoginMSG())));
return true;
}
}
try
{
this.sender = new CommandSource(sender);
execute(this.sender, args);
Component component = this.execute(sender, args);
if (component != null)
{
send(sender, component);
}
}
catch (CommandArgumentException ex)
{
send(getUsage().replace("<command>", getLabel()));
send(sender, getUsage().replace("<command>", getLabel()));
}
catch (PlayerNotFoundException | CommandFailException ex)
{
send(ex.getMessage());
send(sender, ex.getMessage());
}
catch (ConsoleMustDefinePlayerException ex)
{
send(tl("consoleMustDefinePlayer"));
send(sender, tl("consoleMustDefinePlayer"));
}
catch (ConsoleOnlyException ex)
{
send(tl("consoleOnly"));
send(sender, tl("consoleOnly"));
}
return true;
}
@Override
public List<String> tabComplete(CommandSender sender, String alias, String[] args)
{
if (!matches(alias))
{
return ImmutableList.of();
}
if (sender instanceof Player player)
{
this.sender = new CommandSource(player);
PlexPlayer plexPlayer = PlayerCache.getPlexPlayerMap().get(player.getUniqueId());
if (plexPlayer.getRankFromString().isAtLeast(getLevel()))
{
return onTabComplete(this.sender, args);
}
else
{
return ImmutableList.of();
}
}
else
{
this.sender = new CommandSource(sender);
return onTabComplete(this.sender, args);
}
}
@Override
public List<String> onTabComplete(CommandSender sender, Command cmd, String label, String[] args)
{
return tabComplete(sender, label, args);
}
private boolean matches(String label)
{
@ -173,49 +138,67 @@ public abstract class PlexCommand extends Command implements TabExecutor, IPlexC
return false;
}
protected void send(String s, CommandSource sender)
protected PlexPlayer getPlexPlayer(@NotNull Player player)
{
sender.send(s);
return DataUtils.getPlayer(player.getUniqueId());
}
protected void send(String s, Player player)
protected void send(Audience audience, String s)
{
player.sendMessage(s);
audience.sendMessage(componentFromString(s));
}
protected void send(Audience audience, Component component)
{
audience.sendMessage(component);
}
protected boolean isAdmin(PlexPlayer plexPlayer)
{
return Plex.get().getRankManager().isAdmin(plexPlayer);
}
protected boolean isAdmin(CommandSender sender)
{
if (!(sender instanceof Player player)) return true;
PlexPlayer plexPlayer = getPlexPlayer(player);
return Plex.get().getRankManager().isAdmin(plexPlayer);
}
protected boolean isAdmin(String name)
{
PlexPlayer plexPlayer = DataUtils.getPlayer(name);
return Plex.get().getRankManager().isAdmin(plexPlayer);
}
protected boolean isConsole()
protected boolean isSeniorAdmin(CommandSender sender)
{
if (!(sender instanceof Player player)) return true;
PlexPlayer plexPlayer = getPlexPlayer(player);
return Plex.get().getRankManager().isSeniorAdmin(plexPlayer);
}
protected UUID getUUID(CommandSender sender)
{
if (!(sender instanceof Player player)) return null;
return player.getUniqueId();
}
protected boolean isConsole(CommandSender sender)
{
return !(sender instanceof Player);
}
protected String tl(String s, Object... objects)
protected Component tl(String s, Object... objects)
{
return PlexUtils.tl(s, objects);
return componentFromString(PlexUtils.tl(s, objects));
}
protected String usage(String s)
protected Component usage(String s)
{
return ChatColor.YELLOW + "Correct Usage: " + ChatColor.GRAY + s;
}
protected void send(String s)
{
if (sender == null)
{
return;
}
send(s, sender);
return componentFromString(ChatColor.YELLOW + "Correct Usage: " + ChatColor.GRAY + s);
}
protected Player getNonNullPlayer(String name)
@ -254,11 +237,16 @@ public abstract class PlexCommand extends Command implements TabExecutor, IPlexC
World world = Bukkit.getWorld(name);
if (world == null)
{
throw new CommandFailException(tl("worldNotFound"));
throw new CommandFailException(PlexUtils.tl("worldNotFound"));
}
return world;
}
protected Component componentFromString(String s)
{
return LegacyComponentSerializer.legacyAmpersand().deserialize(s);
}
public Rank getLevel()
{
return level;