- Auto register commands using modified ReflectionsUtil#getClassesFrom(String)

- Add /eject
- Begin /enchant

src/main/java/dev/plex/command/AdminInfoCommand.java

@@ -0,0 +1,32 @@
+package dev.plex.command;
+
+import dev.plex.TFMExtras;
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.rank.enums.Rank;
+import java.util.List;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandParameters(name = "admininfo", description = "Information on how to apply for admin", aliases = "ai,si,staffinfo")
+@CommandPermissions(level = Rank.OP, permission = "plex.tfmextras.admininfo")
+public class AdminInfoCommand extends PlexCommand
+{
+    private static final List<Component> ADMIN_INFO = TFMExtras.getModule().getConfig().getStringList("server.admininfo")
+            .stream().map(info -> MiniMessage.miniMessage().deserialize(info)).toList();
+
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
+    {
+        if (ADMIN_INFO.isEmpty())
+        {
+            return messageComponent("emptyAdminInfo");
+        }
+        ADMIN_INFO.forEach(component -> send(sender, component));
+        return null;
+    }
+}

src/main/java/dev/plex/command/AttributeListCommand.java

@@ -0,0 +1,24 @@
+package dev.plex.command;
+
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.rank.enums.Rank;
+import java.util.Arrays;
+import net.kyori.adventure.text.Component;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandParameters(name = "attributes", description = "Lists all possible attributes", aliases = "attributelist,attrlist")
+@CommandPermissions(level = Rank.OP, permission = "plex.tfmextras.attrlist")
+public class AttributeListCommand extends PlexCommand
+{
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
+    {
+        return messageComponent("attributeList", StringUtils.join(Arrays.stream(Attribute.values()).map(Enum::name).toList(), ", "));
+    }
+}

src/main/java/dev/plex/command/AutoClearCommand.java

@@ -0,0 +1,48 @@
+package dev.plex.command;
+
+import dev.plex.TFMExtras;
+import dev.plex.cache.DataUtils;
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.exception.PlayerNotFoundException;
+import dev.plex.player.PlexPlayer;
+import dev.plex.rank.enums.Rank;
+import java.util.List;
+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 = "autoclear", description = "Toggle whether or not a player has their inventory automatically cleared when they join", usage = "/<command> <player>", aliases = "aclear,ac")
+@CommandPermissions(level = Rank.ADMIN, permission = "plex.tfmextras.autoclear")
+public class AutoClearCommand extends PlexCommand
+{
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
+    {
+        if (args.length == 0)
+        {
+            return usage();
+        }
+        PlexPlayer target = DataUtils.getPlayer(args[0]);
+        if (target == null)
+        {
+            throw new PlayerNotFoundException();
+        }
+        List<String> names = TFMExtras.getModule().getConfig().getStringList("server.clear-on-join");
+        boolean isEnabled = names.contains(target.getName());
+        if (!isEnabled)
+        {
+            names.add(target.getName());
+        }
+        else
+        {
+            names.remove(target.getName());
+        }
+        TFMExtras.getModule().getConfig().set("server.clear-on-join", names);
+        TFMExtras.getModule().getConfig().save();
+        isEnabled = !isEnabled;
+        return messageComponent("modifiedAutoClear", target.getName(), isEnabled ? "now" : "no longer");
+    }
+}

src/main/java/dev/plex/command/AutoTeleportCommand.java

@@ -0,0 +1,55 @@
+package dev.plex.command;
+
+import dev.plex.TFMExtras;
+import dev.plex.cache.DataUtils;
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.exception.PlayerNotFoundException;
+import dev.plex.player.PlexPlayer;
+import dev.plex.rank.enums.Rank;
+import java.util.List;
+import net.kyori.adventure.text.Component;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandParameters(name = "autoteleport", description = "If a player is specified, it will toggle whether or not the player is automatically teleported when they join. If no player is specified, you will be randomly teleported", usage = "/<command> [player]", aliases = "autotp,rtp,randomtp,tpr")
+@CommandPermissions(level = Rank.OP, permission = "plex.tfmextras.autotp")
+public class AutoTeleportCommand extends PlexCommand
+{
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
+    {
+        if (args.length == 0)
+        {
+            if (sender instanceof ConsoleCommandSender)
+            {
+                return usage();
+            }
+            player.teleportAsync(TFMExtras.getRandomLocation(player.getWorld()));
+            return null;
+        }
+        checkRank(sender, Rank.ADMIN, "plex.tfmextras.autotp.other");
+        PlexPlayer target = DataUtils.getPlayer(args[0]);
+        if (target == null)
+        {
+            throw new PlayerNotFoundException();
+        }
+        List<String> names = TFMExtras.getModule().getConfig().getStringList("server.teleport-on-join");
+        boolean isEnabled = names.contains(target.getName());
+        if (!isEnabled)
+        {
+            names.add(target.getName());
+        }
+        else
+        {
+            names.remove(target.getName());
+        }
+        TFMExtras.getModule().getConfig().set("server.teleport-on-join", names);
+        TFMExtras.getModule().getConfig().save();
+        isEnabled = !isEnabled;
+        return messageComponent("modifiedAutoTeleport", target.getName(), isEnabled ? "now" : "no longer");
+    }
+}

src/main/java/dev/plex/command/BanListCommand.java

@@ -0,0 +1,51 @@
+package dev.plex.command;
+
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.punishment.Punishment;
+import dev.plex.rank.enums.Rank;
+import java.util.stream.Collectors;
+import net.kyori.adventure.text.Component;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandParameters(name = "banlist", description = "Manages the banlist", usage = "/<command> [purge]")
+@CommandPermissions(level = Rank.ADMIN, permission = "plex.tfmextras.banlist")
+public class BanListCommand extends PlexCommand
+{
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
+    {
+        if (args.length == 0)
+        {
+            plugin.getPunishmentManager().getActiveBans().whenComplete((punishments, throwable) ->
+            {
+                send(sender, mmString("<gold>Active Bans (" + punishments.size() + "): <yellow>" + StringUtils.join(punishments.stream().map(Punishment::getPunishedUsername).collect(Collectors.toList()), ", ")));
+            });
+            return null;
+        }
+        if (args[0].equalsIgnoreCase("purge"))
+        {
+            if (sender instanceof Player)
+            {
+                return messageComponent("noPermissionInGame");
+            }
+            if (!sender.getName().equalsIgnoreCase("console"))
+            {
+                if (!checkRank(sender, Rank.EXECUTIVE, "plex.tfmextras.banlist.clear"))
+                {
+                    return null;
+                }
+            }
+            plugin.getPunishmentManager().getActiveBans().whenComplete((punishments, throwable) ->
+            {
+                punishments.forEach(plugin.getPunishmentManager()::unban);
+                send(sender, mmString("<gold>Unbanned " + punishments.size() + " players."));
+            });
+        }
+        return null;
+    }
+}

src/main/java/dev/plex/command/CakeCommand.java

@@ -0,0 +1,36 @@
+package dev.plex.command;
+
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.rank.enums.Rank;
+import dev.plex.util.PlexUtils;
+import dev.plex.util.item.ItemBuilder;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandParameters(name = "cake", description = "For the people that are still alive - gives a cake to everyone on the server")
+@CommandPermissions(level = Rank.ADMIN, permission = "plex.tfmextras.cake")
+public class CakeCommand extends PlexCommand
+{
+    private static final ItemStack CAKE = new ItemBuilder(Material.CAKE)
+            .displayName(MiniMessage.miniMessage().deserialize("<!italic><white>The <dark_gray>Lie"))
+            .build();
+
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
+    {
+        Bukkit.getOnlinePlayers().forEach(p ->
+        {
+            p.getInventory().addItem(CAKE);
+        });
+        PlexUtils.broadcast(messageComponent("cakeLyrics"));
+        return null;
+    }
+}

src/main/java/dev/plex/command/CartSitCommand.java

@@ -0,0 +1,83 @@
+package dev.plex.command;
+
+import dev.plex.Plex;
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.rank.enums.Rank;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandParameters(name = "cartsit", description = "Sit in nearest minecart. If target is in a minecart already, they will be ejected", aliases = "minecartsit")
+@CommandPermissions(level = Rank.NONOP, permission = "plex.tfmextras.cartsit")
+public class CartSitCommand extends PlexCommand
+{
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
+    {
+        if (!(sender instanceof Player) && args.length == 0)
+        {
+            return usage("/cartsit <player>");
+        }
+
+        if (args.length == 0)
+        {
+            if (player.isInsideVehicle())
+            {
+                player.eject();
+            }
+            List<Entity> minecart = player.getNearbyEntities(100, 100, 100).stream().filter(entity -> entity.getType() == EntityType.MINECART).collect(Collectors.toList());
+            if (minecart.isEmpty())
+            {
+                return MiniMessage.miniMessage().deserialize("<red>Could not find a nearby minecart!");
+            }
+            findNearestEntity(player, minecart).whenComplete((entity, throwable) ->
+            {
+                Bukkit.getScheduler().runTask(Plex.get(), () -> entity.addPassenger(player));
+            });
+            return null;
+        }
+        Player target = getNonNullPlayer(args[0]);
+        if (target.isInsideVehicle())
+        {
+            target.eject();
+        }
+        List<Entity> minecart = target.getNearbyEntities(100, 100, 100).stream().filter(entity -> entity.getType() == EntityType.MINECART).collect(Collectors.toList());
+        if (minecart.isEmpty())
+        {
+            return MiniMessage.miniMessage().deserialize("<red>Could not find a nearby minecart near " + target.getName() + "!");
+        }
+        findNearestEntity(target, minecart).whenComplete((entity, throwable) ->
+        {
+            Bukkit.getScheduler().runTask(Plex.get(), () -> entity.addPassenger(target));
+        });
+
+        return null;
+    }
+
+    public CompletableFuture<Entity> findNearestEntity(Player player, List<Entity> entities)
+    {
+        return CompletableFuture.supplyAsync(() ->
+        {
+            Entity nearest = entities.get(0);
+            for (int i = 0; i < entities.size(); i++)
+            {
+                Entity e = entities.get(i);
+                if (player.getLocation().distance(e.getLocation()) < player.getLocation().distance(nearest.getLocation()))
+                {
+                    nearest = e;
+                }
+            }
+            return nearest;
+        });
+    }
+}

src/main/java/dev/plex/command/ClearChatCommand.java

@@ -0,0 +1,32 @@
+package dev.plex.command;
+
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.rank.enums.Rank;
+import dev.plex.util.PlexUtils;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandParameters(name = "clearchat", description = "Clears the chat", aliases = "cc,cleanchat,chatclear")
+@CommandPermissions(level = Rank.ADMIN, permission = "plex.tfmextras.clearchat")
+public class ClearChatCommand extends PlexCommand
+{
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
+    {
+        Bukkit.getOnlinePlayers().stream().filter(p -> !silentCheckRank(p, Rank.ADMIN, "plex.tfmextras.clearchat"))
+                .forEach(p ->
+                {
+                    for (int i = 0; i < 100; i++)
+                    {
+                        send(p, "");
+                    }
+                });
+        PlexUtils.broadcast(messageComponent("chatCleared", sender.getName()));
+        return null;
+    }
+}

src/main/java/dev/plex/command/CloudClearCommand.java

@@ -0,0 +1,35 @@
+package dev.plex.command;
+
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.rank.enums.Rank;
+import dev.plex.util.PlexUtils;
+import java.util.Collection;
+import java.util.concurrent.atomic.AtomicInteger;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandParameters(name = "cloudclear", description = "Clears lingering potion area effect clouds", aliases = "clearcloud,aeclear")
+@CommandPermissions(level = Rank.ADMIN, permission = "plex.tfmextras.cloudclear")
+public class CloudClearCommand extends PlexCommand
+{
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
+    {
+        AtomicInteger removed = new AtomicInteger();
+        Bukkit.getWorlds().stream().map(World::getEntities).flatMap(Collection::stream).filter(entity -> entity.getType() == EntityType.AREA_EFFECT_CLOUD).peek(entity ->
+        {
+            entity.remove();
+            removed.incrementAndGet();
+        });
+        PlexUtils.broadcast(messageComponent("areaEffectCloudClear", sender.getName()));
+        return MiniMessage.miniMessage().deserialize("<gray>" + removed.get() + " area effect clouds removed.");
+    }
+}

src/main/java/dev/plex/command/EjectCommand.java

@@ -0,0 +1,26 @@
+package dev.plex.command;
+
+import dev.plex.TFMExtras;
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.source.RequiredCommandSource;
+import dev.plex.rank.enums.Rank;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+@CommandParameters(name = "eject", description = "Removes all passengers from a player")
+@CommandPermissions(level = Rank.OP, permission = "plex.tfmextras.eject", source = RequiredCommandSource.IN_GAME)
+public class EjectCommand extends PlexCommand {
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args) {
+        final int passengers = player.getPassengers().size();
+        player.eject();
+        return MiniMessage.miniMessage().deserialize("<gray>Ejected " + passengers + " passengers.");
+    }
+}

src/main/java/dev/plex/command/EnchantCommand.java

@@ -0,0 +1,70 @@
+package dev.plex.command;
+
+import com.google.common.collect.Lists;
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.source.RequiredCommandSource;
+import dev.plex.rank.enums.Rank;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.apache.commons.lang3.StringUtils;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.command.CommandSender;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Arrays;
+import java.util.List;
+
+@CommandParameters(name = "enchant", description = "Enchants an item", usage = "/<command> <add | reset | list | addall | remove>", aliases = "enchantment")
+@CommandPermissions(level = Rank.OP, permission = "plex.tfmextras.enchant", source = RequiredCommandSource.IN_GAME)
+public class EnchantCommand extends PlexCommand {
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args) {
+        if (args.length == 0)
+        {
+            return usage();
+        }
+
+        ItemStack item = player.getInventory().getItemInMainHand();
+        if (item.getType() == Material.AIR)
+        {
+            return MiniMessage.miniMessage().deserialize("<red>You must be holding an enchantable item.");
+        }
+
+        if (args.length == 1)
+        {
+            if (args[0].equalsIgnoreCase("list"))
+            {
+                return MiniMessage.miniMessage().deserialize("<dark_gray>All possible enchantments are for this item are: <gray>" + StringUtils.join(getEnchantmentNames(item), ", "));
+            }
+            if (args[0].equalsIgnoreCase("addall"))
+            {
+                getEnchantments(item).forEach(enchantment -> item.addEnchantment(enchantment, enchantment.getMaxLevel()));
+                player.playSound(player, Sound.BLOCK_ANVIL_USE, 1, 1);
+                return MiniMessage.miniMessage().deserialize("<gray>Added all possible enchantments for this item.");
+            }
+            if (args[0].equalsIgnoreCase("reset"))
+            {
+                item.getEnchantments().keySet().forEach(item::removeEnchantment);
+                player.playSound(player, Sound.BLOCK_ANVIL_USE, 1, 1);
+                return MiniMessage.miniMessage().deserialize("<gray>Removed every enchantment from this item.");
+            }
+        }
+        return null;
+    }
+
+    private List<Enchantment> getEnchantments(ItemStack item) {
+        List<Enchantment> enchants = Lists.newArrayList();
+        Arrays.stream(Enchantment.values()).filter(enchantment -> enchantment.canEnchantItem(item)).forEach(enchants::add);
+        return enchants;
+    }
+
+    private String[] getEnchantmentNames(ItemStack item) {
+        return getEnchantments(item).stream().map(enchantment -> enchantment.key().value()).toArray(String[]::new);
+    }
+}

src/main/java/dev/plex/command/EnglishMfCommand.java

@@ -0,0 +1,47 @@
+package dev.plex.command;
+
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.rank.enums.Rank;
+import dev.plex.util.PlexUtils;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Credit to AcidicCyanide <3
+ * Credit to "TheDeus-Group" for the messages :)
+ */
+
+@CommandParameters(name = "emf", description = "Speak english.", usage = "/<command> <player>")
+@CommandPermissions(level = Rank.ADMIN, permission = "plex.tfmextras.emf")
+public class EnglishMfCommand extends PlexCommand
+{
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
+    {
+        if (args.length == 0)
+        {
+            return usage();
+        }
+        Player target = getNonNullPlayer(args[0]);
+        target.sendMessage(mmString("<red>ENGLISH MOTHERFUCKER, Do you speak it!?"));
+        PlexUtils.broadcast("<red>" + sender.getName() + " is sick of " + target.getName() + " not speaking English!");
+        target.setHealth(0);
+        target.getWorld().strikeLightningEffect(target.getLocation());
+        return null;
+    }
+
+    @Override
+    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    {
+        return Bukkit.getOnlinePlayers().stream().map(HumanEntity::getName).collect(Collectors.toList());
+    }
+}

src/main/java/dev/plex/command/JumpPadsCommand.java

@@ -0,0 +1,135 @@
+package dev.plex.command;
+
+import dev.plex.TFMExtras;
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.source.RequiredCommandSource;
+import dev.plex.jumppads.JumpPads;
+import dev.plex.jumppads.Mode;
+import dev.plex.rank.enums.Rank;
+import dev.plex.util.PlexUtils;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandParameters(name = "jumppads", usage = "/jumppads <mode> [player]", description = "Enables jump pads for yourself or another player. Mode types available: none, regular, enhanced, extreme, ultimate", aliases = "jp, pads, launchpads")
+@CommandPermissions(level = Rank.OP, permission = "plex.tfmextras.jumppads", source = RequiredCommandSource.ANY)
+public class JumpPadsCommand extends PlexCommand
+{
+    JumpPads jumpPads = TFMExtras.getModule().jumpPads;
+
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
+    {
+        if ((args.length < 1) || (args.length > 2))
+        {
+            return usage();
+        }
+
+        if (args.length == 1)
+        {
+            try
+            {
+                if (sender instanceof ConsoleCommandSender)
+                {
+                    return MiniMessage.miniMessage().deserialize("<red>You must specify a player when running this command from console.");
+                }
+
+                if (player == null)
+                {
+                    return null;
+                }
+
+                if (args[0].equalsIgnoreCase("none") || args[0].equalsIgnoreCase("off"))
+                {
+                    jumpPads.removePlayer(player);
+                    return MiniMessage.miniMessage().deserialize("<gray>You have disabled your jump pads.");
+                }
+
+                Mode mode = Mode.valueOf(args[0].toUpperCase());
+
+                if (jumpPads.get(player) != null)
+                {
+                    if (mode.equals(jumpPads.get(player)))
+                    {
+                        return MiniMessage.miniMessage().deserialize("<red>Your jump pads are already set to " + mode.name() + ".");
+                    }
+                    else
+                    {
+                        jumpPads.updatePlayer(player, mode);
+                        return MiniMessage.miniMessage().deserialize("<aqua>Successfully set your jump pads to " + mode.name() + ".");
+                    }
+                }
+
+                jumpPads.addPlayer(player, mode);
+                return MiniMessage.miniMessage().deserialize("<aqua>Successfully set your jump pads to " + mode.name() + ".");
+            }
+            catch (IllegalArgumentException ignored)
+            {
+                return MiniMessage.miniMessage().deserialize("<red>That is not a valid mode.");
+            }
+        }
+        try
+        {
+            Player p = Bukkit.getPlayer(args[1]);
+
+            if (p == null)
+            {
+                return MiniMessage.miniMessage().deserialize("<red>That player cannot be found.");
+            }
+
+            if (args[0].equalsIgnoreCase("none"))
+            {
+                jumpPads.removePlayer(p);
+                return MiniMessage.miniMessage().deserialize("<gray>Jump pads for " + p.getName() + " have been disabled.");
+            }
+
+            Mode mode = Mode.valueOf(args[0]);
+
+            if (!checkRank(sender, Rank.ADMIN, "plex.tfmextras.jumppads.others"))
+            {
+                return permissionMessage();
+            }
+
+            if (jumpPads.get(p) != null)
+            {
+                if (jumpPads.get(p).equals(mode))
+                {
+                    return MiniMessage.miniMessage().deserialize("<red>Your jump pads are already set to " + mode.name() + ".");
+                }
+
+                jumpPads.updatePlayer(p, mode);
+                return MiniMessage.miniMessage().deserialize("<gray>Jump pads for " + p.getName() + " have been set to " + mode.name() + ".");
+            }
+
+            jumpPads.addPlayer(p, mode);
+            return MiniMessage.miniMessage().deserialize("<gray>Jump pads for " + p.getName() + " have been set to " + mode.name() + ".");
+        }
+        catch (IllegalArgumentException ignored)
+        {
+            return MiniMessage.miniMessage().deserialize("That is not a valid mode.");
+        }
+    }
+
+    @Override
+    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) throws IllegalArgumentException
+    {
+        if (args.length == 1)
+        {
+            return Arrays.asList("none", "normal", "enhanced", "extreme", "ultimate");
+        }
+        else if (args.length == 2)
+        {
+            return PlexUtils.getPlayerNameList();
+        }
+        return Collections.emptyList();
+    }
+}

src/main/java/dev/plex/command/RandomFishCommand.java

@@ -0,0 +1,41 @@
+package dev.plex.command;
+
+import dev.plex.command.annotation.CommandParameters;
+import dev.plex.command.annotation.CommandPermissions;
+import dev.plex.command.source.RequiredCommandSource;
+import dev.plex.rank.enums.Rank;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.block.Block;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@CommandParameters(name = "randomfish", description = "Spawns a random type of fish at your location", aliases = "rfish,bird")
+@CommandPermissions(level = Rank.OP, permission = "plex.tfmextras.randomfish", source = RequiredCommandSource.IN_GAME)
+public class RandomFishCommand extends PlexCommand
+{
+    private static final List<EntityType> FISH_TYPES = Arrays.asList(EntityType.COD, EntityType.SALMON, EntityType.PUFFERFISH, EntityType.TROPICAL_FISH);
+
+    @Override
+    protected Component execute(@NotNull CommandSender sender, @Nullable Player player, @NotNull String[] args)
+    {
+        @Nullable Block block = player.getTargetBlock(15);
+        if (block == null)
+        {
+            return MiniMessage.miniMessage().deserialize("<red>There is no block within 15 blocks of you.");
+        }
+        player.getWorld().spawnEntity(block.getLocation().add(0, 1, 0), randomFish());
+        return MiniMessage.miniMessage().deserialize(":goodbird:");
+    }
+
+    private EntityType randomFish()
+    {
+        return FISH_TYPES.get(ThreadLocalRandom.current().nextInt(FISH_TYPES.size()));
+    }
+}