[LIB] AmpMenus - Advanced Inventory Menus/GUIs

Do you have a technique to create paginated menus? I can only think of hard coding submenu buttons to go to the next page, but this wouldn't work when you don't know how many items are going to be in the menu.

 

Interesting idea, I'll come up with some code for you and maybe add it to the lib

In the latest update I removed the Menu interface and added a Size enum for ItemMenus instead of using raw slot amounts.

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

Why is this so big? All of my menus are handled flawlessly with only 2 tiny classes

 

Good question - I'd actually call this a very small lib for what it can do haha

A couple contributing factors to the size are the detailed documentation and premade MenuItems (BackItem, CloseItem, SubMenuItem, StaticMenuItem) included. Aside from that there are actually only a few classes:

• ItemMenu - Handles mostly everything to do with a menu
• MenuItem - Represents the items in a menu. Stores basic information such as the base ItemStack and the displayname/lore. Implements ItemClickEventHandler to handle ItemClickEvents called when the MenuItem is clicked.
• MenuHolder - Custom InventoryHolder to link the ItemMenu and Inventory. Far better than getting the ItemMenu from the clicked Inventory's name as that could cause conflicts between multiple menus with the same name.
• MenuListener - Listens to bukkit InventoryClickEvents. Checks if the clicked Inventory's holder is a MenuHolder, if so passes the event to the ItemMenu. Has much better performance than for example having a separate listener in each ItemMenu.

If you take a look at the code you can see that it's extremely user friendly. It's also very good for dynamic menus - menus that appear different for different players or in different situations. The two menus shown in the pictures in the OP are a good example of this - the minigame shop uses a single slot in the inventory to let players increase the tier of certain perks. The attribute allocation menu displays a player's attribute levels and lets the player increase/decrease them. The 'increase attribute' buttons only appear green if the player has enough attribute points to actually increase the level.

I also partly answer this question in the OP:
"An object-oriented approach"
"Intended for advanced use cases"
"Because the items in these menus behave differently depending on the player and certain data or conditions, they would not be possible with a traditional plugin such as http://dev.bukkit.org/bukkit-plugins/chest-commands/ and would be impractical to create with a simpler utility such as https://forums.bukkit.org/threads/icon-menu.108342/"

Using this or a similar library leads to much more maintainable code. Your menus may be handled 'flawlessly' but I'm interested in what makes your 2 classes better. I also highly doubt they would be able to cleanly & easily - if at all - replicate the functionality of either of my example menus

Did I mention you only have to create one instance of an ItemMenu and it can be used for any player? I don't know how many times I've seen plugins create a separate menu for every player, or even a new menu every time it gets opened.

 

Well, have a go at what I've done. From what I can see, it does everything yours does.

PlayerGUI:

Code:java

/**
* Represents a GUI only for one player.
*/
public abstract class PlayerGUI implements Listener {
 
    /**
    * The player's uuid.
    */
    private UUID uuid;
 
    /**
    * The inventory.
    */
    private Inventory inventory;
 
    /**
    * Instantiates a new player gui.
    *
    * @param player the player
    * @param title  the title
    * @param slots  the slots
    */
    public PlayerGUI(@NonNull Player player, @NonNull String title, int slots) {
        if (!player.isOnline()) {
            return;
        }
        this.uuid = player.getUniqueId();
        this.inventory = Bukkit.createInventory(null, slots, title);
        Bukkit.getPluginManager().registerEvents(this, PaloozaLobby.getPlugin());
    }
 
    /**
    * Gets the spot.
    *
    * @param row      the row
    * @param position the position
    * @return the spot
    */
    public static int getSpot(int row, int position) {
        return (row * 9) + position - 1;
    }
 
    public static int getInventorySize(int max) {
        if (max <= 9) return 9;
        if (max <= 18) return 18;
        if (max <= 27) return 27;
        if (max <= 36) return 36;
        if (max <= 45) return 45;
        return 54;
    }
 
    /**
    * Adds the item.
    *
    * @param items the items
    */
    public void addItem(ItemStack... items) {
        this.inventory.addItem(items);
    }
 
    /**
    * Sets the item.
    *
    * @param item    the item
    * @param position the position
    */
    public void setItem(ItemStack item, int position) {
        this.inventory.setItem(position, item);
    }
 
    /**
    * Sets the item.
    *
    * @param item    the item
    * @param position the position
    */
    public void setItem(ItemBuilder item, int position) {
        this.inventory.setItem(position, item.build());
    }
 
    /**
    * Gets the inventory.
    *
    * @return the inventory
    */
    public Inventory getInventory() {
        return this.inventory;
    }
 
    /**
    * Sets the size.
    *
    * @param size the new size
    */
    public void setSize(int size) {
        Inventory newInv = Bukkit.createInventory(null, size, this.inventory.getTitle());
        newInv.setContents(this.inventory.getContents());
        this.inventory = newInv;
    }
 
    /**
    * On player quit.
    *
    * @param event the event
    */
    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
    public void onPlayerQuit(PlayerQuitEvent event) {
        if (event.getPlayer().getUniqueId() == this.uuid) {
            HandlerList.unregisterAll(this);
        }
    }
 
    /**
    * On inventory click.
    *
    * @param event the event
    */
    @EventHandler(priority = EventPriority.LOWEST)
    public void onInventoryClick(InventoryClickEvent event) {
        if (event.getWhoClicked().getUniqueId().equals(this.uuid) && event.getInventory().equals(this.inventory)) {
            if (event.getCurrentItem() != null && this.inventory.contains(event.getCurrentItem())) {
                event.setCancelled(true);
                this.onClick((Player) event.getWhoClicked(), event.getCurrentItem());
                HumanEntity who = event.getWhoClicked();
                ((Player) who).playSound(who.getLocation(), Sound.FIRE_IGNITE, 0.3f, 0.3f);
            }
        }
    }
 
    /**
    * On inventory close.
    *
    * @param event the event
    */
    @EventHandler
    public void onInventoryClose(InventoryCloseEvent event) {
        if (event.getInventory().equals(this.inventory) && event.getPlayer() instanceof Player) {
            if (this.onClose((Player) event.getPlayer())) {
                ((Player) event.getPlayer()).playSound(event.getPlayer().getLocation(), Sound.CHEST_CLOSE, 0.3f, 0.3f);
            }
        }
    }
 
    /**
    * On click.
    *
    * @param player the player
    * @param item  the item
    */
    public abstract void onClick(Player player, ItemStack item);
 
    public boolean onClose(Player player) {
        return true;
    }
 
}
 

GUI

Code:java

 
/**
* The Class GUI.
*/
public abstract class GUI implements Listener {
 
    /**
    * Gets the inventory.
    *
    * @return the inventory
    */
    @Getter
    private final Inventory inventory;
 
    /**
    * Instantiates a new gui.
    *
    * @param title the title
    * @param size  the size
    */
    public GUI(String title, int size) {
        this.inventory = Bukkit.createInventory(null, size, title);
 
        Bukkit.getPluginManager().registerEvents(this, PaloozaLobby.getPlugin());
    }
 
    /**
    * Adds the item.
    *
    * @param item the item
    */
    public void addItem(ItemBuilder item) {
        this.inventory.addItem(item.build());
    }
 
    /**
    * Sets the item.
    *
    * @param index the index
    * @param item  the item
    */
    public void setItem(int index, ItemBuilder item) {
        this.inventory.setItem(index, item.build());
    }
 
    /**
    * Gets the spot.
    *
    * @param row      the row
    * @param position the position
    * @return the spot
    */
    public int getSpot(int row, int position) {
        return (row * 9) + position - 1;
    }
 
    /**
    * On inventory click.
    *
    * @param event the event
    */
    @EventHandler
    public void onInventoryClick(InventoryClickEvent event) {
        if (event.getInventory().equals(this.inventory)) {
            if (event.getCurrentItem() != null && this.inventory.contains(event.getCurrentItem()) && event.getWhoClicked() instanceof Player) {
                this.onClick((Player) event.getWhoClicked(), event.getCurrentItem());
                HumanEntity who = event.getWhoClicked();
                ((Player) who).playSound(who.getLocation(), Sound.FIRE_IGNITE, 0.3f, 0.3f);
                event.setCancelled(true);
            }
        }
    }
 
    /**
    * On inventory close.
    *
    * @param event the event
    */
    @EventHandler
    public void onInventoryClose(InventoryCloseEvent event) {
        if (event.getInventory().equals(this.inventory) && event.getPlayer() instanceof Player) {
            if (this.onClose((Player) event.getPlayer())) {
                ((Player) event.getPlayer()).playSound(event.getPlayer().getLocation(), Sound.CHEST_CLOSE, 0.3f, 0.3f);
            }
        }
    }
 
    /**
    * On click.
    *
    * @param player the player
    * @param item  the item
    */
    public abstract void onClick(Player player, ItemStack item);
 
    /**
    * On close. Needs to be overriden.
    *
    * @param player the player
    * @return true, if you want to play the closing sound.
    */
    public boolean onClose(Player player) {
        // to be overriden
        return true;
    }
 
}
 

 

Your GUI classes are sufficient for inventory menus that do not change. However you're missing the entire purpose of AmpMenus - it's intended for advanced uses cases, where the inventory frequently changes.

This cannot be accomplished with your GUI class. It's possible with your PlayerGUI class, however you are forced to create an entire new PlayerGUI instance for every player. Not to mention you would basically need to create a new PlayerGUI instance or manually modify all the ItemStacks in the Inventory every time it needs to change. However with AmpMenus this becomes extremely simple because dynamic inventories is what it's meant to do.

Straight from the second line of the OP. This has come in handy for many uses:

• MenuItems for Minigame Shop Menus.
• A server teleporter menu. I extend MenuItem and add an extra string in the constructor - the name of the server that the item will teleport you to. Then I add the logic that teleports you to that server when the item is clicked. Then I can create the entire menu in a couple lines.
• Items in a vote token shop to buy pets. I extend MenuItem and add an extra string in the constructor - the name of the pet. Then I add the logic to check if you can afford the pet, if you haven't already bought it, and to add permission for the pet.
• Basically any situation in which you will be creating multiple MenuItems that do pretty much the same thing. For custom MenuItems that you're only going to use once, instead of extending MenuItem you could just use an anonymous class and modify it's methods there.

Your GUI classes fall under this reasoning as well - small and easy to use, but they aren't very flexible and they only support static menus.

Now, what if you only need a static menu? There are several reasons AmpMenus is still superior.

In your case you are required to create a new instance of PlayerGUI for every player, wasting resources.​

Your Inventories have a null InventoryHolder.​

Your GUI classes each contain their own listener. When an InventoryClickEvent is called every single GUI checks if the Inventory clicked is equal to the GUI's Inventory which could lead to serious performance issues, for example if you have a PlayerGUI instance for every player on a full 100 slot server. However, AmpMenus uses this single MenuListener to control all of the ItemMenus. It does this by checking if the clicked Inventory's holder is a MenuHolder, and if so it gets the ItemMenu instance from the MenuHolder and passes the event to it.​

• AmpMenus comes with a StaticMenuItem that does not rebuild itself every time the ItemMenu is opened or updated to improve the performance of completely or partially static menus.

Nobody is forcing you to use AmpMenus - however if you think your GUIs do everything AmpMenus does, I challenge you to do this and post the code. Then I'll post my code and we can see which is cleaner & simpler

 

How are mine not dynamic? Just setItem anytime works. They support both static and dynamic easily.
I do however like the approach that you and some others use, that detect clicking a specific item. However, how easily do those items change? If I wanted to change "Upgrade Level #1" -> "Upgrade Level #2", are your menus advanced to do that? From what it appears, I couldn't do that.

 

You could do that with the TieredGameItem in the example MenuItems for Minigame Shops link - basically there's a GameItem which extends MenuItem to buy non-upgradeable perks, and then the TieredGameItem adds the upgrade level functionality

 

ampayne2
Sorry for this noob question but I'm new to maven.
Do you know why my plugin trys to register the Listener while it isn't loaded? I'm sure I create the menu in my onEnable() so it should be loaded.

 

I removed the line in an ItemMenu's constructor that registers the listener automatically for version 1.3 in this commit - should solve the problem, just make sure you register the listener on enable or before players can open any menus.

 

Suggestion: automatically replace &[0-9][a-f] with corresponding color codes.

 

In Inventory titles and ItemStack display names/lore?

 

ampayne2 Yep.

"&4&lSHOP &7- &8&oYou have &6XXX &8tokens"

will be much better than

"" + ChatColor.DARK_RED + ChatColor.BOLD + "SHOP " + ChatColor.GRAY + "- " + ChatColor.DARK_GRAY + ChatColor.ITALIC + "You have " + ChatColor.GOLD + "XXX" + ChatColor.DARK_GRAY + "tokens"

 

It's totally personal preference. I personally like using ChatColor because it's more verbose. You can easily use ChatColor.translateAlternateColorCodes('&',textToTranslate) before putting using the text.

 

mahlooo That means you will need to use a method to handle every string.

Personal preference doesn't mean it must have no meaning at all. And after all, adding a built-in ChatColor.translateAlternateColorCodes() doesn't affect users, if someone decides to use ChatColor, he can still use it and no problem will be caused.

By the way, operator "+" cannot be applied to two ChatColors. So, instead of ChatColor.RED + ChatColor.BOLD + "PLAYER", you will need to add an empty string like this, "" + ChatColor.RED + ChatColor.BOLD + "PLAYER", otherwise compile error.

 

TigerHix I'm not for or against the idea of implementing it because I will be using ChatColor regardless, but hard coding ChatColor.translateAlternateColorCodes into every String in the library forces a behavior that isn't required for it to function. If someone only uses default colored text, it would be wasting resources every time.

 

mahlooo First, that case is very rare; second, even though there is someone that likes default color codes, like Hypixel's scoreboards before 2014/8, if handling some strings - replacing & with § can "waste resource", then that computer is not suitable for opening a Bukkit server as well.

 

TigerHix
I like the idea and thanks for the suggestion but I'm probably going to side with mahlooo here, because it forces a behavior that isn't required and would slightly slow it down. Also using ChatColor may make lines longer but it's still better for readability because some people don't know instantly what certain codes are.

 

ampayne2 No problem, after all you are the author.

 

Just wondering if there's a way to use this without maven? I'm using it for menus, and maven doesn't work for me for whatever reason. Is there a way I can use this with regular craftbukkit? I put the .jar as an external jar in eclipse, but the server won't let me run it.

 

Are you sure you're not running into issues because of craftbukkit being taken down? All the AmpMenus builds on Jenkins and the maven repo were built before then so it should work fine. What error are you getting in maven/the server console?

 

Oh no, maven just doesn't work.
For now I included it in the .jar since no other mods use it, but if I wanted to use it in a separate plugin what then?

 

It looks like the maven repo is down, I'll let the owner of it know and it should be back up soon
Btw, including it in the .jar manually is fine as that's basically what maven does automatically for you.

 

Alright, thanks! c:

 

ampayne2 It would be nice if you could detect right click/shift clicks
Thoughts?

 

ampayne2 Hello, i have an issue with this lib :d I have :
My Menu class :

Code:java

public class ShopMenu extends ItemMenu {
 
    public ShopMenu(JavaPlugin plugin, Size size) {
        super("MENU", size.FOUR_LINE, main.instance);
 
        // Adding items to your ItemMenu
        setItem(17, new TestItem());
    }
 
    @Override
    public void open(Player player) {
        super.open(player);
    }
}

My TestItem class:

Code:java

public class TestItem extends MenuItem {
    private static final String DISPLAY_NAME = ChatColor.BLUE + "Click me!";
    private static final ItemStack ICON = new ItemStack(Material.COAL_BLOCK);
 
    public TestItem() {
        super(DISPLAY_NAME, ICON);
    }
 
 
    @Override
    public void onItemClick(ItemClickEvent event) {
        event.getPlayer().sendMessage("It works!");
    }
 
    @Override
    public ItemStack getFinalIcon(Player player) {
        ItemStack finalIcon = super.getFinalIcon(player);
        if (player.isFlying()) {
            finalIcon.setType(Material.LEASH);
            ItemMeta meta = finalIcon.getItemMeta();
            meta.setDisplayName(ChatColor.DARK_RED + "It works too!");
            finalIcon.setItemMeta(meta);
        }
        return finalIcon;
    }
}

And my main class:

Code:java

public class main extends JavaPlugin {
 
    static main instance;
 
    @Override
    public void onEnable() {
        instance = this;
        getServer().getPluginManager().registerEvents(new listen(), this);
    }
}
 

Listener class:

Code:java

public class listen implements Listener {
 
    ShopMenu menu;
 
    @EventHandler
    public void e(PlayerEggThrowEvent e) {
        menu.open(e.getPlayer());
    }
}
 

Every time I throw an egg, i have a null pointer exception at line 13 of listen, wich is the open method.

Thanks, Lzp_Hiro

 

Lzp_Hiro
You never set the Variable menu to something.
menu = new ShopMenu();

 

I've done this.

 

Thank you so much! I'm feeling really stupid right now ^^

 

just started using this for some GUI's in my plugin but i'm either overthinking something or i'm just not understanding. I've got a MainMenu class that has a menuItem that i want to open a submenu called ManagementMenu, i'm not understanding how to make that menuItem in the MainMenu open the ManagementMenu.