feat(items): add bound role control items

src/main/java/games/dmg/spigottyrant/BukkitRoleControlItemService.java

@@ -0,0 +1,146 @@
+package games.dmg.spigottyrant;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataType;
+import org.bukkit.plugin.Plugin;
+
+public final class BukkitRoleControlItemService implements RoleControlItemService {
+    private final NamespacedKey roleKey;
+    private final NamespacedKey ownerKey;
+    private final PluginSettings settings;
+
+    public BukkitRoleControlItemService(Plugin plugin, PluginSettings settings) {
+        roleKey = new NamespacedKey(plugin, "role-control");
+        ownerKey = new NamespacedKey(plugin, "role-control-owner");
+        this.settings = settings;
+    }
+
+    @Override
+    public void recover(Player player, GameState game) {
+        Optional<RoleControl> required = RoleControlItemPolicy.requiredRole(
+            game, player.getUniqueId()
+        );
+        if (required.isEmpty() || contains(player, required.orElseThrow())) {
+            return;
+        }
+        Map<Integer, ItemStack> leftovers = player.getInventory().addItem(
+            create(player.getUniqueId(), required.orElseThrow())
+        );
+        if (!leftovers.isEmpty()) {
+            String command = required.orElseThrow() == RoleControl.TYRANT
+                ? "/tyrant item" : "/vigilante item";
+            player.sendMessage(ChatColor.RED
+                + "Your inventory is full. Make room and use " + command + ".");
+        }
+    }
+
+    @Override
+    public boolean isBoundRoleControlItem(ItemStack item) {
+        return role(item).isPresent() && owner(item).isPresent();
+    }
+
+    @Override
+    public Optional<RoleControl> role(ItemStack item) {
+        String value = metadata(item, roleKey);
+        if (value == null) {
+            return Optional.empty();
+        }
+        try {
+            return Optional.of(RoleControl.valueOf(value));
+        } catch (IllegalArgumentException exception) {
+            return Optional.empty();
+        }
+    }
+
+    @Override
+    public Optional<UUID> owner(ItemStack item) {
+        String value = metadata(item, ownerKey);
+        if (value == null) {
+            return Optional.empty();
+        }
+        try {
+            return Optional.of(UUID.fromString(value));
+        } catch (IllegalArgumentException exception) {
+            return Optional.empty();
+        }
+    }
+
+    @Override
+    public void removeInvalid(Player player, GameState game) {
+        Optional<RoleControl> required = RoleControlItemPolicy.requiredRole(
+            game, player.getUniqueId()
+        );
+        boolean retained = false;
+        ItemStack[] contents = player.getInventory().getContents();
+        for (int index = 0; index < contents.length; index++) {
+            ItemStack item = contents[index];
+            if (!isBoundRoleControlItem(item)) {
+                continue;
+            }
+            boolean valid = !retained
+                && owner(item).filter(player.getUniqueId()::equals).isPresent()
+                && role(item).equals(required);
+            if (valid) {
+                retained = true;
+            } else {
+                player.getInventory().setItem(index, null);
+            }
+        }
+    }
+
+    @Override
+    public void removeAll(Player player) {
+        ItemStack[] contents = player.getInventory().getContents();
+        for (int index = 0; index < contents.length; index++) {
+            if (isBoundRoleControlItem(contents[index])) {
+                player.getInventory().setItem(index, null);
+            }
+        }
+    }
+
+    private ItemStack create(UUID ownerId, RoleControl role) {
+        PluginSettings.AbilityItemSettings configured = role == RoleControl.TYRANT
+            ? settings.tyrantControlItem() : settings.vigilanteControlItem();
+        Material material = Material.matchMaterial(configured.material());
+        if (material == null) {
+            throw new IllegalStateException("Configured role control material is unavailable");
+        }
+        ItemStack item = new ItemStack(material);
+        ItemMeta meta = item.getItemMeta();
+        meta.setDisplayName(ChatColor.GOLD + configured.name());
+        meta.getPersistentDataContainer().set(
+            roleKey, PersistentDataType.STRING, role.name()
+        );
+        meta.getPersistentDataContainer().set(
+            ownerKey, PersistentDataType.STRING, ownerId.toString()
+        );
+        item.setItemMeta(meta);
+        return item;
+    }
+
+    private boolean contains(Player player, RoleControl role) {
+        for (ItemStack item : player.getInventory().getContents()) {
+            if (owner(item).filter(player.getUniqueId()::equals).isPresent()
+                    && role(item).filter(role::equals).isPresent()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static String metadata(ItemStack item, NamespacedKey key) {
+        if (item == null || !item.hasItemMeta()) {
+            return null;
+        }
+        return item.getItemMeta().getPersistentDataContainer()
+            .get(key, PersistentDataType.STRING);
+    }
+}

src/main/java/games/dmg/spigottyrant/PluginSettings.java

@@ -39,6 +39,8 @@ public record PluginSettings(
     AbilityItemSettings fixerItem,
     AbilityItemSettings tamerItem,
     AbilityItemSettings capturedMobItem,
+    AbilityItemSettings tyrantControlItem,
+    AbilityItemSettings vigilanteControlItem,
     String recoveryCommand,
     String inventoryFullMessage,
     boolean freezeTimersWhilePaused
@@ -78,6 +80,10 @@ public record PluginSettings(
         fixerItem = Objects.requireNonNull(fixerItem, "fixerItem");
         tamerItem = Objects.requireNonNull(tamerItem, "tamerItem");
         capturedMobItem = Objects.requireNonNull(capturedMobItem, "capturedMobItem");
+        tyrantControlItem = Objects.requireNonNull(tyrantControlItem, "tyrantControlItem");
+        vigilanteControlItem = Objects.requireNonNull(
+            vigilanteControlItem, "vigilanteControlItem"
+        );
         recoveryCommand = requireText(recoveryCommand, "recovery-command");
         inventoryFullMessage = requireText(inventoryFullMessage, "inventory-full-message");
     }
@@ -114,6 +120,14 @@ public record PluginSettings(
             item(values, "fixer-item", new AbilityItemSettings("STICK", "Fixer's Wrench")),
             item(values, "tamer-item", new AbilityItemSettings("FISHING_ROD", "Tamer's Lead")),
             item(values, "captured-mob-item", new AbilityItemSettings("PAPER", "Captured Mob")),
+            item(
+                values, "tyrant-control-item",
+                new AbilityItemSettings("NETHER_STAR", "Tyrant Control")
+            ),
+            item(
+                values, "vigilante-control-item",
+                new AbilityItemSettings("COMPASS", "Vigilante Control")
+            ),
             string(values, "recovery-command", "/tyrant item"),
             string(
                 values,

src/main/java/games/dmg/spigottyrant/PluginSettingsValidator.java

@@ -12,6 +12,8 @@ public final class PluginSettingsValidator {
         validateItem(settings.fixerItem(), "fixer-item");
         validateItem(settings.tamerItem(), "tamer-item");
         validateItem(settings.capturedMobItem(), "captured-mob-item");
+        validateItem(settings.tyrantControlItem(), "tyrant-control-item");
+        validateItem(settings.vigilanteControlItem(), "vigilante-control-item");
         for (String entityType : settings.deniedMobTypes()) {
             try {
                 EntityType.valueOf(entityType);

src/main/java/games/dmg/spigottyrant/RoleControl.java

@@ -0,0 +1,6 @@
+package games.dmg.spigottyrant;
+
+public enum RoleControl {
+    TYRANT,
+    VIGILANTE
+}

src/main/java/games/dmg/spigottyrant/RoleControlItemListener.java

@@ -0,0 +1,146 @@
+package games.dmg.spigottyrant;
+
+import org.bukkit.entity.ItemFrame;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockDispenseEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.entity.EntityPickupItemEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryDragEvent;
+import org.bukkit.event.inventory.InventoryMoveItemEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.inventory.ItemStack;
+
+public final class RoleControlItemListener implements Listener {
+    private final TyrantStateManager stateManager;
+    private final RoleControlItemService items;
+    private final TyrantControlPanel tyrantPanel;
+    private final VigilanteControlPanel vigilantePanel;
+
+    public RoleControlItemListener(
+        TyrantStateManager stateManager,
+        RoleControlItemService items,
+        TyrantControlPanel tyrantPanel,
+        VigilanteControlPanel vigilantePanel
+    ) {
+        this.stateManager = stateManager;
+        this.items = items;
+        this.tyrantPanel = tyrantPanel;
+        this.vigilantePanel = vigilantePanel;
+    }
+
+    @EventHandler
+    public void onInteract(PlayerInteractEvent event) {
+        ItemStack item = event.getItem();
+        if (!items.isBoundRoleControlItem(item)
+                || event.getAction() != Action.RIGHT_CLICK_AIR
+                    && event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        event.setCancelled(true);
+        Player player = event.getPlayer();
+        GameState game = stateManager.game();
+        java.util.Optional<RoleControl> required = RoleControlItemPolicy.requiredRole(
+            game, player.getUniqueId()
+        );
+        boolean valid = items.owner(item).filter(player.getUniqueId()::equals).isPresent()
+            && items.role(item).equals(required)
+            && game.lifecycle() == GameLifecycle.RUNNING;
+        if (!valid) {
+            items.removeInvalid(player, game);
+            player.sendMessage(org.bukkit.ChatColor.RED
+                + "That role control item is no longer valid.");
+            return;
+        }
+        if (required.orElseThrow() == RoleControl.TYRANT) {
+            tyrantPanel.open(player);
+        } else {
+            vigilantePanel.open(player);
+        }
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) {
+        items.removeInvalid(event.getPlayer(), stateManager.game());
+        items.recover(event.getPlayer(), stateManager.game());
+    }
+
+    @EventHandler
+    public void onDrop(PlayerDropItemEvent event) {
+        if (items.isBoundRoleControlItem(event.getItemDrop().getItemStack())) {
+            event.getItemDrop().remove();
+        }
+    }
+
+    @EventHandler
+    public void onPickup(EntityPickupItemEvent event) {
+        if (items.isBoundRoleControlItem(event.getItem().getItemStack())) {
+            event.setCancelled(true);
+            event.getItem().remove();
+        }
+    }
+
+    @EventHandler
+    public void onInventoryClick(InventoryClickEvent event) {
+        if (items.isBoundRoleControlItem(event.getCurrentItem())
+                || items.isBoundRoleControlItem(event.getCursor())) {
+            if (!(event.getWhoClicked() instanceof Player player)
+                    || event.isShiftClick()
+                    || event.getClickedInventory() == null
+                    || !event.getClickedInventory().equals(player.getInventory())) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler
+    public void onInventoryDrag(InventoryDragEvent event) {
+        if (items.isBoundRoleControlItem(event.getOldCursor())
+                || event.getNewItems().values().stream()
+                    .anyMatch(items::isBoundRoleControlItem)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onInventoryMove(InventoryMoveItemEvent event) {
+        if (items.isBoundRoleControlItem(event.getItem())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onPlace(BlockPlaceEvent event) {
+        if (items.isBoundRoleControlItem(event.getItemInHand())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onDispense(BlockDispenseEvent event) {
+        if (items.isBoundRoleControlItem(event.getItem())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onFrame(PlayerInteractEntityEvent event) {
+        if (event.getRightClicked() instanceof ItemFrame
+                && items.isBoundRoleControlItem(event.getPlayer().getInventory()
+                    .getItem(event.getHand()))) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onDeath(PlayerDeathEvent event) {
+        event.getDrops().removeIf(items::isBoundRoleControlItem);
+    }
+}

src/main/java/games/dmg/spigottyrant/RoleControlItemPolicy.java

@@ -0,0 +1,19 @@
+package games.dmg.spigottyrant;
+
+import java.util.Optional;
+import java.util.UUID;
+
+public final class RoleControlItemPolicy {
+    private RoleControlItemPolicy() {
+    }
+
+    public static Optional<RoleControl> requiredRole(GameState game, UUID playerId) {
+        if (game.tyrantId().filter(playerId::equals).isPresent()) {
+            return Optional.of(RoleControl.TYRANT);
+        }
+        if (game.vigilanteId().filter(playerId::equals).isPresent()) {
+            return Optional.of(RoleControl.VIGILANTE);
+        }
+        return Optional.empty();
+    }
+}

src/main/java/games/dmg/spigottyrant/RoleControlItemRefreshTask.java

@@ -0,0 +1,31 @@
+package games.dmg.spigottyrant;
+
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+
+public final class RoleControlItemRefreshTask implements Runnable {
+    private final TyrantStateManager stateManager;
+    private final RoleControlItemService items;
+    private final Server server;
+
+    public RoleControlItemRefreshTask(
+        TyrantStateManager stateManager,
+        RoleControlItemService items,
+        Server server
+    ) {
+        this.stateManager = stateManager;
+        this.items = items;
+        this.server = server;
+    }
+
+    @Override
+    public void run() {
+        GameState game = stateManager.game();
+        for (Player player : server.getOnlinePlayers()) {
+            items.removeInvalid(player, game);
+            if (!player.isDead()) {
+                items.recover(player, game);
+            }
+        }
+    }
+}

src/main/java/games/dmg/spigottyrant/RoleControlItemService.java

@@ -0,0 +1,20 @@
+package games.dmg.spigottyrant;
+
+import java.util.Optional;
+import java.util.UUID;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public interface RoleControlItemService {
+    void recover(Player player, GameState game);
+
+    boolean isBoundRoleControlItem(ItemStack item);
+
+    Optional<RoleControl> role(ItemStack item);
+
+    Optional<UUID> owner(ItemStack item);
+
+    void removeInvalid(Player player, GameState game);
+
+    void removeAll(Player player);
+}

src/main/java/games/dmg/spigottyrant/SpigotTyrantPlugin.java

@@ -54,6 +54,9 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
         FollowerService followers = new FollowerService();
         AbilityReadinessService readiness = new AbilityReadinessService();
         AbilityItemService abilityItems = new BukkitAbilityItemService(this, settings);
+        RoleControlItemService roleControlItems = new BukkitRoleControlItemService(
+            this, settings
+        );
         CapturedMobItemService capturedMobItems = new BukkitCapturedMobItemService(
             this, settings
         );
@@ -109,11 +112,13 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
                 tyrantPresentation,
                 abilityItems,
                 new TyrantAbilityService(settings.rosterIntelligenceCooldown()),
-                controlPanel
+                controlPanel,
+                roleControlItems
             ));
         Objects.requireNonNull(getCommand("vigilante"), "Missing vigilante metadata")
             .setExecutor(new VigilanteCommand(
-                stateManager, followers, onlinePlayers, vigilanteControlPanel
+                stateManager, followers, onlinePlayers, vigilanteControlPanel,
+                roleControlItems
             ));
         Objects.requireNonNull(getCommand("tyrantadmin"), "Missing tyrantadmin metadata")
             .setExecutor(new TyrantAdminCommand(
@@ -181,6 +186,12 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
             new BoundItemListener(abilityItems),
             this
         );
+        getServer().getPluginManager().registerEvents(
+            new RoleControlItemListener(
+                stateManager, roleControlItems, controlPanel, vigilanteControlPanel
+            ),
+            this
+        );
         getServer().getPluginManager().registerEvents(
             new TamerListener(
                 stateManager, abilityItems, capturedMobItems, capturedMobs,
@@ -229,6 +240,12 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
             20L,
             20L
         );
+        getServer().getScheduler().runTaskTimer(
+            this,
+            new RoleControlItemRefreshTask(stateManager, roleControlItems, getServer()),
+            1L,
+            10L
+        );
         getServer().getScheduler().runTaskTimer(this, stateManager::saveIfDirty, 600L, 600L);
         getLogger().info("Spigot Tyrant enabled.");
     }

src/main/java/games/dmg/spigottyrant/TyrantCommand.java

@@ -21,6 +21,7 @@ public final class TyrantCommand implements CommandExecutor {
     private final AbilityItemService abilityItems;
     private final TyrantAbilityService tyrantAbilities;
     private final TyrantControlPanel controlPanel;
+    private final RoleControlItemService roleControlItems;
 
     public TyrantCommand(
         TyrantStateManager stateManager,
@@ -44,7 +45,21 @@ public final class TyrantCommand implements CommandExecutor {
             stateManager, progression, new ClassAssignmentService(),
             new BukkitOnlinePlayerDirectory(), Clock.systemUTC(),
             new ParticipationService(Duration.ofDays(7)), null, null, null,
-            new TyrantAbilityService(Duration.ofHours(24)), controlPanel
+            new TyrantAbilityService(Duration.ofHours(24)), controlPanel, null
+        );
+    }
+
+    public TyrantCommand(
+        TyrantStateManager stateManager,
+        TyrantProgressionService progression,
+        TyrantControlPanel controlPanel,
+        RoleControlItemService roleControlItems
+    ) {
+        this(
+            stateManager, progression, new ClassAssignmentService(),
+            new BukkitOnlinePlayerDirectory(), Clock.systemUTC(),
+            new ParticipationService(Duration.ofDays(7)), null, null, null,
+            new TyrantAbilityService(Duration.ofHours(24)), controlPanel, roleControlItems
         );
     }
 
@@ -58,7 +73,8 @@ public final class TyrantCommand implements CommandExecutor {
         this(
             stateManager, progression, assignments, onlinePlayers, clock,
             new ParticipationService(Duration.ofDays(7)), null, null, null,
-            new TyrantAbilityService(Duration.ofHours(24)), TyrantCommand::unavailablePanel
+            new TyrantAbilityService(Duration.ofHours(24)), TyrantCommand::unavailablePanel,
+            null
         );
     }
 
@@ -77,7 +93,7 @@ public final class TyrantCommand implements CommandExecutor {
         this(
             stateManager, progression, assignments, onlinePlayers, clock, participation,
             relinquishment, presentation, abilityItems, tyrantAbilities,
-            TyrantCommand::unavailablePanel
+            TyrantCommand::unavailablePanel, null
         );
     }
 
@@ -93,6 +109,26 @@ public final class TyrantCommand implements CommandExecutor {
         AbilityItemService abilityItems,
         TyrantAbilityService tyrantAbilities,
         TyrantControlPanel controlPanel
+    ) {
+        this(
+            stateManager, progression, assignments, onlinePlayers, clock, participation,
+            relinquishment, presentation, abilityItems, tyrantAbilities, controlPanel, null
+        );
+    }
+
+    public TyrantCommand(
+        TyrantStateManager stateManager,
+        TyrantProgressionService progression,
+        ClassAssignmentService assignments,
+        OnlinePlayerDirectory onlinePlayers,
+        Clock clock,
+        ParticipationService participation,
+        RoleRelinquishmentService relinquishment,
+        TyrantPresentation presentation,
+        AbilityItemService abilityItems,
+        TyrantAbilityService tyrantAbilities,
+        TyrantControlPanel controlPanel,
+        RoleControlItemService roleControlItems
     ) {
         this.stateManager = stateManager;
         this.progression = progression;
@@ -105,6 +141,7 @@ public final class TyrantCommand implements CommandExecutor {
         this.abilityItems = abilityItems;
         this.tyrantAbilities = tyrantAbilities;
         this.controlPanel = controlPanel;
+        this.roleControlItems = roleControlItems;
     }
 
     @Override
@@ -308,14 +345,21 @@ public final class TyrantCommand implements CommandExecutor {
     }
 
     private void recoverItems(Player player) {
-        if (abilityItems == null) {
-            player.sendMessage(ChatColor.RED + "Ability item recovery is unavailable.");
+        if (abilityItems == null && roleControlItems == null) {
+            player.sendMessage(ChatColor.RED + "Item recovery is unavailable.");
             return;
         }
-        PlayerState state = stateManager.player(player.getUniqueId(), player.getName());
-        abilityItems.recover(player, state);
+        if (abilityItems != null) {
+            PlayerState state = stateManager.player(player.getUniqueId(), player.getName());
+            abilityItems.recover(player, state);
+        }
+        GameState game = stateManager.game();
+        if (roleControlItems != null
+                && game.tyrantId().filter(player.getUniqueId()::equals).isPresent()) {
+            roleControlItems.recover(player, game);
+        }
         player.sendMessage(ChatColor.YELLOW
-            + "Recovered every currently ready missing class item that could fit.");
+            + "Recovered every currently available missing Tyrant item that could fit.");
     }
 
     private void relinquish(Player player, String[] arguments) {

src/main/java/games/dmg/spigottyrant/VigilanteCommand.java

@@ -12,6 +12,7 @@ public final class VigilanteCommand implements CommandExecutor {
     private final FollowerService followers;
     private final OnlinePlayerDirectory onlinePlayers;
     private final VigilanteControlPanel controlPanel;
+    private final RoleControlItemService roleControlItems;
 
     public VigilanteCommand(
         TyrantStateManager stateManager,
@@ -21,7 +22,8 @@ public final class VigilanteCommand implements CommandExecutor {
         this(
             stateManager, followers, onlinePlayers,
             player -> player.sendMessage(ChatColor.RED
-                + "The Vigilante control panel is unavailable.")
+                + "The Vigilante control panel is unavailable."),
+            null
         );
     }
 
@@ -30,11 +32,22 @@ public final class VigilanteCommand implements CommandExecutor {
         FollowerService followers,
         OnlinePlayerDirectory onlinePlayers,
         VigilanteControlPanel controlPanel
+    ) {
+        this(stateManager, followers, onlinePlayers, controlPanel, null);
+    }
+
+    public VigilanteCommand(
+        TyrantStateManager stateManager,
+        FollowerService followers,
+        OnlinePlayerDirectory onlinePlayers,
+        VigilanteControlPanel controlPanel,
+        RoleControlItemService roleControlItems
     ) {
         this.stateManager = stateManager;
         this.followers = followers;
         this.onlinePlayers = onlinePlayers;
         this.controlPanel = controlPanel;
+        this.roleControlItems = roleControlItems;
     }
 
     @Override
@@ -53,6 +66,16 @@ public final class VigilanteCommand implements CommandExecutor {
             controlPanel.open(player);
             return true;
         }
+        if (arguments.length == 1 && arguments[0].equalsIgnoreCase("item")) {
+            if (roleControlItems == null) {
+                player.sendMessage(ChatColor.RED + "Role item recovery is unavailable.");
+            } else {
+                roleControlItems.recover(player, stateManager.game());
+                player.sendMessage(ChatColor.YELLOW
+                    + "Recovered the missing Vigilante control item if it could fit.");
+            }
+            return true;
+        }
         FollowerResult result;
         Player target = null;
         if (arguments.length == 1 && arguments[0].equalsIgnoreCase("accept")) {
@@ -81,7 +104,7 @@ public final class VigilanteCommand implements CommandExecutor {
                 );
         } else {
             player.sendMessage(ChatColor.YELLOW
-                + "Usage: /vigilante <menu|invite <player>|accept|dismiss <player>|leave>");
+                + "Usage: /vigilante <menu|item|invite <player>|accept|dismiss <player>|leave>");
             return true;
         }
         if (result.status() == FollowerStatus.JOINED